Đã đến mùa tựu trường! Vì vậy, đối với một công việc bán thời gian, bạn đang giúp đỡ tại thư viện của trường. Vấn đề là, người thủ thư đứng đầu thậm chí chưa bao giờ nghe thấy từ "Dewey Decimal", chứ chưa nói đến việc thực hiện hệ thống đó. Thay vào đó, hệ thống phân loại đang sử dụng đã phát triển "hữu cơ" khi thư viện đã mở rộng ...

Trong nỗ lực giữ sự tỉnh táo của bạn, bạn đã chọn viết một chương trình để giúp bạn sắp xếp sách khi chúng được trả lại, vì khốn cho bạn nếu bạn sắp xếp sách sai. (Thủ thư đứng đầu RẤT nghiêm ngặt.)

Đầu ra đầu vào

• Đầu vào sẽ là một danh sách các tiêu đề sách (giả thuyết), mỗi tiêu đề trên mỗi dòng, từ STDIN / ngôn ngữ tương đương.
• Bạn có thể giả sử không quá 100 cuốn sách nhập vào một lúc (bạn chỉ có thể mang theo rất nhiều thư viện cùng một lúc).
• Sách có thể có nhiều từ trong tiêu đề của chúng và những từ này có thể được phân tách bằng dấu cách hoặc dấu chấm câu khác (ví dụ: dấu hai chấm :, dấu gạch ngang -, v.v.).
• Để dễ tính toán, giả sử tất cả các tiêu đề là UTF-8.

Đầu ra là cùng một tiêu đề, được sắp xếp theo các quy tắc dưới đây, một lần nữa trên mỗi dòng, tương đương với STDOUT / ngôn ngữ.

Các quy tắc sắp xếp

Sách được sắp xếp số lượng dựa trên giá trị ký tự trung bình của chúng (nghĩa là giá trị ký tự tích lũy chia số lượng ký tự trong tiêu đề sách), được tính theo các quy tắc sau:

• Tất cả các ký tự được tính để xác định số lượng ký tự trong một tiêu đề.
• Chữ thường được tính theo vị trí của chúng trong bảng chữ cái. (a = 1, b = 2, ... z = 26)
• Nếu tiêu đề chứa chữ in hoa, chúng được tính bằng 1,5 giá trị chữ thường của chúng (A = 1,5, B = 3, ... Z = 39). ("Chữ in hoa rất quan trọng!", Thủ thư nói.)
• Mỗi dấu chấm / ký hiệu trong danh sách này !@#$%^&*()-=_+[]\{}|;':",./<>?~được tính -1 từ giá trị tích lũy trước khi tính trung bình. ("Tiêu đề hoành tráng thì không!")
• Nếu tiêu đề chứa một số, được viết bằng chữ số Ả Rập , số đó sẽ bị trừ khỏi giá trị trung bình trước khi sắp xếp. Nhiều chữ số liên tiếp được coi là một số (ví dụ: 42sẽ trừ 42, không trừ 4 và sau đó trừ 2). Các chữ số riêng lẻ không được tính cho giá trị tích lũy (nghĩa là mỗi chữ số đóng góp 0), nhưng DO tính cho số lượng ký tự. Lưu ý rằng điều này có thể dẫn đến một giá trị âm và nên được xử lý thích hợp. (Có tin đồn, người thủ thư đã phải lòng một người hướng dẫn toán học trong vài năm nay.)
• Nếu tiêu đề chứa hai từ riêng biệt bắt đầu bằng một R, cuốn sách sẽ có điểm "vô cực" và được đổ vào một đống ở góc (nghĩa là được sắp xếp ngẫu nhiên ở cuối danh sách). (Người thủ thư đã từng bị một người có những chữ cái đầu đó bỏ rơi, hoặc bạn đã nghe thấy.)
• Không gian không được tính cho giá trị ký tự tích lũy (nghĩa là chúng đóng góp 0), nhưng DO đóng góp vào số lượng ký tự trong một tiêu đề.
• Các ký tự không phù hợp với các quy tắc trên (ví dụ: a ÿ) không được tính cho giá trị ký tự tích lũy (nghĩa là chúng đóng góp 0), nhưng DO đóng góp vào số lượng ký tự trong một tiêu đề.
• Ví dụ: một cuốn sách giả thuyết ÿÿÿÿÿsẽ có "điểm" (0+0+0+0+0) / 5 = 0, nhưng một cuốn sách giả thuyết ÿÿyÿÿsẽ có "điểm" (0+0+25+0+0) / 5 = 5.
• Hai cuốn sách xảy ra để "ghi điểm" giống nhau có thể là Đầu ra theo thứ tự bạn chọn. (Dù sao họ cũng ở trên cùng một kệ)

Ví dụ đầu vào 1

War and Peace
Reading Rainbow: The Best Unicorn Ever
Maus
Home for a Bunny

Ví dụ Kết quả 1 (có "điểm" trong ngoặc đơn để hiển thị lý do - bạn không cần phải in chúng)

War and Peace (8.5)
Home for a Bunny (10.125)
Maus (15.125)
Reading Rainbow: The Best Unicorn Ever (infinity)

Ví dụ đầu vào 2

Matthew
Mark
Luke
John
Revelations

Ví dụ Kết quả 2 (có "điểm số" trong ngoặc đơn để hiển thị lý do - bạn không cần phải in chúng)

Mark (12.375)
John (13)
Revelations (13.545454...)
Luke (13.75)
Matthew (~13.786)

Ví dụ đầu vào 3

42
9 Kings
1:8
7th

Ví dụ Kết quả 3 (có "điểm số" trong ngoặc đơn để hiển thị lý do - bạn không cần phải in chúng)

42 (-42)
1:8 (-9.3333...)
9 Kings (~0.36)
7th (2.3333...)

Những hạn chế khác

• Đây là Code-Golf, bởi vì bạn cần giữ bí mật chương trình khỏi con mắt luôn theo dõi của người thủ thư, và chương trình càng nhỏ thì càng dễ che giấu.
• Hạn chế kẽ hở tiêu chuẩn áp dụng
• Đừng để người thủ thư bắt bạn nghỉ việc bằng cách dành toàn bộ thời gian cho PPCG.

APL (132)

{⎕ML←3⋄⍵[⍋{2='R'+.=↑¨⍵⊂⍨⍵≠' ':!99⋄↑(+/⍎¨'0',⍵⊂⍨⍵∊⎕D)-⍨((+/∊1.5 1×(⍳×∊⍨)∘⍵¨G)-+/⍵∊(⎕UCS 32+⍳94)~'`',⎕D,∊G←(⊂⎕A),⊂⎕UCS 96+⍳26)÷⍴⍵}¨⍵]}

Vì mọi người khác cũng đang làm điều tương tự, đây cũng là một hàm lấy một mảng các tiêu đề và trả về nó được sắp xếp, ví dụ:

      titles
┌─────────────┬──────────────────────────────────────┬────┬────────────────┬───────┬────┬────┬────┬───────────┬──┬───────┬───┬───┐
│War and Peace│Reading Rainbow: The Best Unicorn Ever│Maus│Home for a Bunny│Matthew│Mark│Luke│John│Revelations│42│9 Kings│1:8│7th│
└─────────────┴──────────────────────────────────────┴────┴────────────────┴───────┴────┴────┴────┴───────────┴──┴───────┴───┴───┘

      {⎕ML←3⋄⍵[⍋{2='R'+.=↑¨⍵⊂⍨⍵≠' ':!99⋄↑(+/⍎¨'0',⍵⊂⍨⍵∊⎕D)-⍨((+/∊1.5 1×(⍳×∊⍨)∘⍵¨G)-+/⍵∊(⎕UCS 32+⍳94)~'`',⎕D,∊G←(⊂⎕A),⊂⎕UCS 96+⍳26)÷⍴⍵}¨⍵]}titles
┌──┬───┬───────┬───┬─────────────┬────────────────┬────┬────┬───────────┬────┬───────┬────┬──────────────────────────────────────┐
│42│1:8│9 Kings│7th│War and Peace│Home for a Bunny│Mark│John│Revelations│Luke│Matthew│Maus│Reading Rainbow: The Best Unicorn Ever│
└──┴───┴───────┴───┴─────────────┴────────────────┴────┴────┴───────────┴────┴───────┴────┴──────────────────────────────────────┘

Giải trình:

• ⎕ML←3: đặt ⎕MLthành 3(cho ⊂)
• ⍵[⍋{... }¨⍵]: Sắp xếp đầu vào theo các giá trị được trả về từ hàm bên trong
  • ↑¨⍵⊂⍨⍵≠' ': lấy ký tự đầu tiên của mỗi từ
  • 2='R'+.=: xem nếu hai trong số này là 'R'.
  • :!99: nếu vậy, hãy trả lại 99! (≈ 9,3 × 10 ¹⁵⁵ ). Điều này không hẳn là vô cùng, nhưng nó sẽ làm được: một tiêu đề không bao giờ có thể có số điểm lớn hơn 38 lần chiều dài của nó (ZZZZ ...), miễn là không có tiêu đề nào lớn hơn khoảng 2 × 10 ¹³⁰ yottabyte, nó được đảm bảo rằng những thứ này sẽ ở cuối
  • ⋄: nếu không thì:
  • (... )÷⍴⍵: chia số điểm cho độ dài ⍵sau khi tính toán:
    • G←(⊂⎕A),(⎕UCS 96+⍳26): lưu trữ bằng Gchữ in hoa và chữ thường
    • (⎕UCS 32+⍳94)~'`',⎕D,∊G: các ký tự ASCII có thể in được, ngoại trừ các chữ cái, chữ số, dấu cách và '`', là các ký tự được trừ đi một điểm. (Điều này ngắn hơn viết tất cả ra, vì Gđược sử dụng sau này.)
    • +/⍵∊: đếm số lượng các ký tự này trong ⍵
    • -: trừ cái này khỏi:
    • +/∊1.5 1×(⍳×∊⍨)∘⍵¨G: tổng 1,5 × điểm cho các chữ viết hoa và 1 × điểm cho các chữ cái viết thường.
  • -⍨: sau đó, trừ tổng số các số trong ⍵:
    • ⍵⊂⍨⍵∊⎕D: tìm các nhóm chữ số trong ⍵
    • '0',: thêm '0', để ngăn danh sách trống
    • ⍎¨: đánh giá từng chuỗi
    • +/: tìm tổng

Lua 5.3, 366 364 byte

r={}for i,s in ipairs(arg)do n=0 s:gsub("%l",function(a)n=n+(a:byte()-96)end):gsub("%u",function(a)n=n+(a:byte()-64)*1.5 end):gsub("%p",function(a)n=n-1 end):gsub("^R?.- R.- ?R?",function()n=math.huge end)m=n/utf8.len(s)s:gsub("%d+",function(a)m=m-a end)table.insert(r,{s=s,n=m})end table.sort(r,function(a,b)return a.n<b.n end)for i,v in ipairs(r)do print(v.s)end

Mã này chỉ hoạt động trong Lua 5.3 vì nó cần xử lý các ký tự Unicode. Nếu bạn không quan tâm đến Unicode, thì hãy thay thế "utf8" bằng "chuỗi" và nó sẽ hoạt động tốt với Lua 5.2 hoặc 5.1.

Nó lấy đầu vào của nó từ các đối số dòng lệnh, vì vậy hoặc chạy nó từ dòng lệnh hoặc đặt mã này lên trên câu trả lời của tôi:

arg = {"Title 1", "Title 2", "Title 3"}

Mathicala, 253 216 byte (214 ký tự)

r=RegularExpression;c=ToCharacterCode;f=SortBy[Tr@Flatten@Reap[StringCases[#,
{r@"(\\bR.*)+"->∞,r@"\\d+":>0Sow@-FromDigits@"$0",r@"[a-z]":>c@"$0"-96,
r@"[A-Z]":>1.5c@"$0"-96,r@"[!-/:-@[-_{-~]"->-1}]/StringLength@#]&]

Gọi hàm như f[{"42", "9 Kings", "1:8", "7th"}]; nó sẽ trả về một danh sách sắp xếp của các đầu vào.

Chỉ cần làm cho nó! Mathematica của mô hình kết hợp không phải là ngắn gọn khi chuỗi có liên quan, và tôi chỉ bị giết bởi những tên dài. Hai byte thêm dành cho Infinityký tự unicode.

(Hãy cho tôi biết nếu tôi rơi vào bất kỳ lỗ hổng tiêu chuẩn nào.)

Cập nhật

Nhìn kỹ hơn vào câu trả lời của edc65, có vẻ như OP sẽ chấp nhận một chức năng sắp xếp danh sách các chuỗi. Với ý nghĩ đó, chúng ta có thể sử dụng dạng cong SortBy(mà Mathicala gọi là "dạng toán tử"); với một đối số (hàm được áp dụng cho các thành phần danh sách để xác định thứ tự của chúng), nó hoạt động giống như một hàm lấy một đối số, trả về dạng đã sắp xếp của đầu vào; đó là, SortBy[list, f]tương đương với (SortBy[f])[list].

Ung dung

Function[{titles},
  SortBy[titles, Function[{str}, (* sort by function value *)
    Total[Flatten[Reap[ (* total up all the parts *)
      StringCases[str, {
        RegularExpression["(\\bR.*){2}"] -> Infinity
          (* matches R at the start of a word twice, adds infinity to the total *),
        RegularExpression["\\d+"] :> 0 * Sow[-FromDigits["$0"]]
          (* matches a number, Sows it for Reap to collect, then multiplies by zero
                                                          to not affect the average *),
        RegularExpression["[a-z]"] :> ToCharacterCode["$0"] - 96
          (* matches a lowercase letter and returns its value *),
        RegularExpression["[A-Z]"] :> 1.5 ToCharacterCode["$0"] - 96
          (* matches an uppercase letter and returns 1.5 its value *),
        RegularExpression["[!-/:-@[-_{-~]"] -> -1
          (* matches a 'grandiose' symbol and returns -1 *)
      }] / StringLength[#] (* averages character values *)
    ]]]
  ]]
]

JavaScript (ES6), 210 218 251

Là một hàm với một đối số mảng, được trả về sắp xếp.

f=L=>(S=s=>([...s].map(c=>t-=(a=s.charCodeAt(l++))>32&a<48|a>57&a<65|a>90&a<96|a>122&a<127?1:a>64&a<123?96-(a<96?a*1.5:a):0,l=t=0),s.split(/\D/).map(n=>t-=n,t/=l),t/!s.split(/\bR/)[2]),L.sort((a,b)=>S(a)-S(b)))

//TEST

test1=['War and Peace','Reading Rainbow: The Best Unicorn Ever','Maus','Home for a Bunny']
test2=['Matthew','Mark','Luke','John','Revelations']
test3=['42','9 Kings','1:8','7th']

;O.innerHTML=f(test1)+'\n\n'+f(test2)+'\n\n'+f(test3);

// The comparing function used to sort, more readable

Sort=s=>(
  t = 0, // running total
  l = 0, // to calc the string length avoiding the '.length' property
  [...s].map(c=>{
    a=s.charCodeAt(l++);
    t-=a>32&a<48|a>57&a<65|a>90&a<96|a>122&a<127
      ? 1 // symbols (ASCII char except space, alphanumeric and backtick)
      : a>64&a<123 
        ? 96-(a<96?a*1.5:a) // alphabetic both upcase and lowcase, and backtick
        // lowcase: 96-a, upcase (64-a)*1.5=>96-a*1.5, backtick is 96 and 96-96 == 0
        : 0 // else space, non ASCII, and numeric : 0
  }),
  t = t/l, // average
  s.split(/\D/).map(n=>t-=n), // sub number values
  f = s.split(/\bR/)[2], // split at words starting with R, if less then 2 f is undefined
  t/!f // dividing by not f I can get the infinity I need
)

<pre id=O></pre>

C #, 352 349 byte

Do sự kỳ diệu của linq:

class A{static void Main(string[]a){foreach(var x in a.OrderBy(b=>{var s="0";int j=0;return Regex.Split(b,@"[^\w]+").Count(l=>l[0]=='R')==2?(1/0d):b.Aggregate(0d,(d,e)=>{if(e>47&e<58){s+=e;return d;}d+=(e>64&e<91)?(e-64)*1.5:(e>96&e<123)?e-96:e>32&e<127&e!=96?-1:0;j+=int.Parse(s);s="0";return d;})/b.Length-j-int.Parse(s);}))Console.WriteLine(x);}}

Có thể đã lưu thêm 6 byte nếu backtick sẽ được đưa vào danh sách dấu chấm câu!

class A
{
    static void Main(string[] a)
    {
        foreach (var x in a.OrderBy(b =>
            {
                var s = "0";
                int j = 0;
                return Regex.Split(b, @"[^\w]+").Count(l => l[0] == 'R') == 2
                    ? (1 / 0d)
                        : b.Aggregate(0d, (d, e) =>
                        {
                            if (e > 47 & e < 58) { s += e; return d; }
                            d += (e > 64 & e < 91) ? (e - 64) * 1.5 : (e > 96 & e < 123) ? e - 96 : e > 32 & e < 127 & e != 96 ? -1 : 0;
                            j += int.Parse(s);
                            s = "0";
                            return d;
                        }) / b.Length - j - int.Parse(s);
            }))
            Console.WriteLine(x);
    }

}

Đi, 755 byte

package main
import("os"
"fmt"
"math"
"bufio"
"regexp"
"sort"
"strconv")
type F float64
type T []F
func(t T)Swap(i,j int){t[i],t[j],S[i],S[j]=t[j],t[i],S[j],S[i]}
func(t T)Len()int{return len(t)}
func(t T)Less(i,j int)bool{return t[i]<t[j]}
var S []string
func main(){var t T
for{b:=bufio.NewReader(os.Stdin)
w,_,_:=b.ReadLine()
if len(w)==0{break}
u:=string(w)
var v F
for _,c:=range u{if 96<c&&c<123{v+=F(c)-F(96)}else
if 64<c&&c<91{v+=(F(c)-64)*1.5}else
if (48>c&&c>32)||(c>57&&c<127){v-=1}}
a:=v/F(len(w))
r,_:=regexp.Compile("[0-9]+")
n:=r.FindAllString(string(w),-1)
for _,x:=range n{y,_:=strconv.Atoi(x);a-=F(y)}
if m,_:=regexp.Match("((^| )R.*){2}",w);m{a=F(math.Inf(1))}
S=append(S,u)
t=append(t,a)}
sort.Sort(t)
for _,o:=range S{fmt.Println(o)}}

Phiên bản được định dạng:

package main

import (
    "bufio"
    "fmt"
    "math"
    "os"
    "regexp"
    "sort"
    "strconv"
)

type F float64
type T []F

func (t T) Swap(i, j int)      { t[i], t[j], S[i], S[j] = t[j], t[i], S[j], S[i] }
func (t T) Len() int           { return len(t) }
func (t T) Less(i, j int) bool { return t[i] < t[j] }

var S []string

func main() {
    var t T
    for {
        b := bufio.NewReader(os.Stdin)
        w, _, _ := b.ReadLine()
        if len(w) == 0 {
            break
        }
        u := string(w)
        var v F
        for _, c := range u {
            if 96 < c && c < 123 {
                v += F(c) - F(96)
            } else if 64 < c && c < 91 {
                v += (F(c) - 64) * 1.5
            } else if (48 > c && c > 32) || (c > 57 && c < 127) {
                v -= 1
            }
        }
        a := v / F(len(w))
        r, _ := regexp.Compile("[0-9]+")
        n := r.FindAllString(string(w), -1)
        for _, x := range n {
            y, _ := strconv.Atoi(x)
            a -= F(y)
        }
        if m, _ := regexp.Match("((^| )R.*){2}", w); m {
            a = F(math.Inf(1))
        }
        S = append(S, u)
        t = append(t, a)
    }
    sort.Sort(t)
    for _, o := range S {
        fmt.Println(o)
    }
}

Việc thực hiện một giao diện sắp xếp tùy chỉnh làm cho nó dài hơn dự kiến. Chương trình đọc từ STDIN cho đến khi kết thúc dòng trống oa đầu vào.

PHP, 362 367 Byte

<?for(;$w=fgets(STDIN);$S[]=$w){for($l=$i=mb_strlen($w);$i--;){$c=array_sum(unpack("C*",mb_substr($w,$i,1)));96<$c&&$c<123 and $v+=$c-96 or 64<$c&&$c<91 and $v+=1.5*$c-96 or 48<$c&&$c>32||$c>57&&$c<127 and $v-=1;}$v/=$l;preg_match_all("/\d+/",$w,$m);$v-=array_sum($m[0]);preg_match("/((^| )R.*){2}/",$w)&&$v=INF;$t[]=$v;}array_multisort($t,$S);echo join("
",$S);

Phiên bản được định dạng:

<?php
for (; $w = fgets(STDIN); $S[] = $w) {
    for ($l = $i = mb_strlen($w); $i--;) {
        $c = array_sum(unpack("C*", mb_substr($w, $i, 1)));
        96 < $c && $c < 123 and $v += $c - 96
        or 64 < $c && $c < 91 and $v += 1.5 * $c - 96
        or 48 < $c && $c > 32 || $c > 57 && $c < 127 and $v -= 1;
    }
    $v /= $l;
    preg_match_all("/\d+/", $w, $m);
    $v -= array_sum($m[0]);
    preg_match("/((^| )R.*){2}/", $w) && $v = INF;
    $t[] = $v;
}
array_multisort($t, $S);
echo join("
", $S); 

Dòng thú vị:

$c = array_sum(unpack("C*", mb_substr($w, $i, 1)));

Chuyển đổi một ký tự UTF-8 thành các giá trị byte của nó và tính tổng chúng, để chúng ta nhận được giá trị thực cho các ký tự ASCII và giá trị cao hơn 127 cho các ký tự đa dòng.

96 < $c && $c < 123 and $v += $c - 96
or 64 < $c && $c < 91 and $v += 1.5 * $c - 96
or 48 < $c && $c > 32 || $c > 57 && $c < 127 and $v -= 1;

Làm cho việc sử dụng quyền ưu tiên toán tử thấp andvà orđể gán giá trị ký tự trong một câu lệnh mà không có if.

Perl 5 , 190 byte

sub p{$_=pop;chomp;$c=-y/A-Za-z0-9 \\`//c;map$c+=(32&ord$_?1:1.5)*(31&ord),/[a-z]/gi;$c/=length;map$c-=$_,/\d+/g;$c}say(sort{$y=$b=~/\bR.*\bR/;($x=$a=~/\bR.*\bR/)||$y?$x-$y:(p($a)<=>p$b)}<>)

Hãy thử trực tuyến!