Thử thách

Đưa ra một đại diện ASCII của một số Babylon làm đầu vào, xuất số đó bằng các chữ số Ả Rập phương Tây.

Hệ thống số Babylon

Người Babylon đã tính như thế nào? Điều thú vị là, họ đã sử dụng hệ thống Base 60 với thành phần là hệ thống Base 10. Trước tiên chúng ta hãy xem xét cột đơn vị của hệ thống:

Người Babylon chỉ có ba biểu tượng: T(hoặc, nếu bạn có thể kết xuất nó 𒐕:) đại diện cho 1 và <(hoặc, nếu bạn có thể kết xuất nó 𒌋:) đại diện cho 10 và \(hoặc, nếu bạn kết xuất nó 𒑊:) đại diện cho số không.

Lưu ý: Về mặt kỹ thuật, \(hoặc 𒑊) không phải là số không (vì người Babylon không có khái niệm "không"). 'Zero' được phát minh sau đó, do đó, \một biểu tượng giữ chỗ được thêm vào sau đó để ngăn ngừa sự mơ hồ. Tuy nhiên, với mục đích của thử thách này, nó đủ để coi \là không

Vì vậy, trong mỗi cột, bạn chỉ cần thêm giá trị của các ký hiệu, ví dụ:

<<< = 30
<<<<TTTTTT = 46
TTTTTTTTT = 9
\ = 0

Sẽ không bao giờ có nhiều hơn năm <hoặc nhiều hơn chín Ttrong mỗi cột. \sẽ luôn xuất hiện một mình trong cột.

Bây giờ, chúng ta cần mở rộng điều này để thêm nhiều cột hơn. Điều này hoạt động chính xác như bất kỳ cơ sở sáu mươi nào khác, trong đó bạn nhân giá trị của cột ngoài cùng bên phải với , một bên trái với 60 1 , một bên trái với 60 2 , v.v. Sau đó, bạn cộng giá trị của từng số để lấy giá trị của số.$60^0$$60^1$$60^2$

Các cột sẽ được phân tách bằng khoảng trắng để tránh sự mơ hồ.

Vài ví dụ:

<< <TT = 20*60 + 12*1 = 1212
<<<TT \ TTTT = 32*60^2 + 0*60 + 4*1 = 115204

Quy tắc

• Bạn có thể chấp nhận đầu vào ASCII ( T<\) hoặc đầu vào Unicode ( 𒐕𒌋𒑊)
• Số đã nhập sẽ luôn dưới $10^7$
• Các <s sẽ luôn luôn được ở phía bên trái của Ts trong mỗi cột
• \ sẽ luôn xuất hiện một mình trong một cột

Chiến thắng

Mã ngắn nhất trong byte thắng.

JavaScript (ES6), 44 byte

Đưa đầu vào dưới dạng một mảng các ký tự ASCII.

a=>a.map(c=>k+=c<1?k*59:c<'?'?10:c<{},k=0)|k

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

Làm sao?

Hệ thống số Babylon có thể được xem như một ngôn ngữ 4 hướng dẫn làm việc với một thanh ghi duy nhất - hãy gọi nó là bộ tích lũy.

Bắt đầu với , mỗi ký tự c trong mảng đầu vào a sửa đổi bộ tích lũy k như sau:$k=0$$c$$a$$k$

• space: nhân với 60 (thực hiện như sau: thêm 59 k vào k )$k$$60$$59k$$k$
• <: thêm đến $10$$k$
• T: tăng $k$
• \: không làm gì cả; đây là NOPhướng dẫn của ngôn ngữ này (được triển khai như sau: thêm vào k )$0$$k$

C (gcc) , 140 138 136 byte

• Lưu hai byte nhờ trần .

B,a,b,y;l(char*o){y=B=0,a=1;for(char*n=o;*n;n++,B++[o]=b,a*=60)for(b=0;*n&&*n-32;n++)b+=*n-84?*n-60?:10:1;for(B=a;B/=60;y+=*o++*B);B=y;}

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

Perl 6 , 39 byte

-3 byte nhờ nwellnhof

{:60[.words>>.&{sum .ords X%151 X%27}]}

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

Sử dụng các ký tự chữ hình nêm.

Giải trình:

{                                     }   # Anonymous code block
     .words  # Split input on spaces
           >>.&{                    }  # Convert each value to
                sum   # The sum of:
                    .ords # The codepoints
                          X%151 X%27   # Converted to 0,1 and 10 through modulo
 :60[                                ]  # Convert the list of values to base 60

Thạch ,  13  12 byte

ḲO%7C%13§ḅ60

Một liên kết đơn âm chấp nhận một danh sách các ký tự mang lại một số nguyên.

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

Làm sao?

ḲO%7C%13§ḅ60 - Link: list of characters   e.g. "<<<TT \ TTTT"
Ḳ            - split at spaces                 ["<<<TT", "\", "TTTT"]
 O           - cast to ordinals                [[60,60,60,84,84],[92],[84,84,84,84]]
  %7         - modulo by seven (vectorises)    [[4,4,4,0,0],[1],[0,0,0,0]]
    C        - compliment (1-X)                [[-3,-3,-3,1,1],[0],[1,1,1,1]]
     %13     - modulo by thirteen              [[10,10,10,1,1],[0],[1,1,1,1]]
        §    - sum each                        [32,0,4]
         ḅ60 - convert from base sixty         115204

Một 12: ḲO⁽¡€%:5§ḅ60( ⁽¡€là 1013, vì vậy modulos này 1013bởi Ogiá trị rdinal nhận 53, 5và 1cho <, T, \lần lượt sau đó thực hiện nguyên phân, :bởi 5để có được 10, 1và 0)

05AB1E , 13 byte

8740|Ç%4/O60β

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

Để bù đắp cho sự lười biếng của tôi với câu trả lời Jelly của tôi, đây là một bài nộp trong 05AB1E xD.

Python 2 , 96 93 87 85 byte

lambda s:sum(60**i*sum(8740%ord(c)/4for c in v)for i,v in enumerate(s.split()[::-1]))

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

Đã lưu:

• -1 byte, nhờ ông Xcoder
• -4 byte, nhờ Poon Levi
• -2 byte, nhờ Matthew Jensen

VBA Excel, 121 byte

Giới hạn đối với Văn phòng 32 bit ^dưới LongLongdạng chữ theo loại trong các phiên bản 64 bit

Đưa đầu vào từ ô A1và đầu ra vào cửa sổ ngay lập tức.

a=Split([A1]):u=UBound(a):For i=0 To u:v=a(i):j=InStrRev(v,"<"):s=s+(j*10-(InStr(1,v,"T")>0)*(Len(v)-j))*60^(u-i):Next:?s

Ungolfed và bình luận

a=Split([A1])       '' Split input into array
u=UBound(a)         '' Get length of array
For i=0 To u        '' Iter from 0 to length
v=a(i)              '' Get i'th column of input
j=InStrRev(v,"<")   '' Get count of <'s in input
                    '' Multiply count of <'s by 10; check for any T's, if present
                    ''   add count of T's
t=t+(j*10-(InStr(1,v,"T")>0)*(Len(v)-j))
    *60^(u-i)       '' Multiply by base
Next                '' Loop
?s                  '' Output to the VBE immediate window

APL Dyalog , 33 30 byte

{+/(⌊10*⍵-3)×60*+\2=⍵}'\ T<'⍳⌽

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

Chỉnh sửa: -3 byte nhờ ngn

'\ T<'⍳thay thế các ký tự bằng số (vị trí của chúng trong hằng chuỗi) và ⌽đảo ngược đầu vào sao cho 'chữ số' quan trọng nhất là cuối cùng. Điều này cho phép +\2=duy trì số lần chạy của công suất mong muốn là 60 (được áp dụng bởi 60*) bằng cách đếm số lần một khoảng trắng (chỉ số 2 trong hằng chuỗi) gặp phải.

⌊10*⍵-3cung cấp sức mạnh mong muốn của mười cho mỗi nhân vật. Thứ tự của các ký tự trong hằng chuỗi và độ lệch -3 gây ra '\' và không gian chuyển sang số âm, dẫn đến phân số khi các ký tự đó được nâng lên lũy thừa 10, cho phép chúng bị loại bỏ ⌊.

Tất cả những gì chúng ta phải làm bây giờ là nhân các số có lũy thừa 10 chữ số với các giá trị lũy thừa của 60 và tổng hợp số tiền với +/.

Python 2 , 62 byte

lambda s:reduce(lambda x,y:x+[10,0,59*x,1]["<\ ".find(y)],s,0)

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

Điều này sử dụng kỹ thuật từ câu trả lời của Arnauld .

Canvas , 20 17 16 byte

Ｓ｛｛<≡ＡײT≡］∑］<ｃ┴

Hãy thử nó ở đây!

Giải trình:

E{          ]     map over input split on spaces
  {       ]         map over the characters
   <≡A×               (x=="<") * 10
       ²T≡            x=="T"
           ∑        sum all of the results
             <c┴  and encode from base (codepoint of "<") to 10

APL (NARS ⎕io ← 0), 28 ký tự, 56 byte

{60⊥{+/⍵⍳⍨10⍴'\T'}¨⍵⊂⍨⍵≠' '}

một số thử nghiệm với kiểm tra loại:

  q←{60⊥{+/⍵⍳⍨10⍴'\T'}¨⍵⊂⍨⍵≠' '}

  o←⎕fmt
  o q '<< <TT'
1212
~~~~
  o q '<<<TT \ TTTT'
115204
~~~~~~

Mỗi loại kết quả là số.

JavaScript (Node.js) , 122 114 107 106 83 byte

a=>a.split` `.map(b=>[...b].map(c=>x+=c<'T'?10:c<'U',x=0)&&x).reduce((a,b)=>a*60+b)

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

Tôi hơi bị ám ảnh với các hoạt động mảng "kiểu chức năng", sử dụng đầu vào ASCII, theo như tôi có thể nói, JS không giỏi lắm trong việc lấy mã hóa

Tôi giữ điều này vì lợi ích của hậu thế, nhưng đây là một giải pháp ngây thơ / ngu ngốc, tôi khuyên bạn nên xem câu trả lời của Arnauld, điều thú vị hơn nhiều khi thực hiện thử thách

Võng mạc , 29 26 23 byte

<
10*T
+`^(.*)¶
60*$1
T

Hãy thử trực tuyến! Sử dụng phân tách dòng mới, nhưng liên kết bao gồm tiêu đề để sử dụng khoảng trắng thay vì thuận tiện. Chỉnh sửa: Đã lưu 3 byte với sự trợ giúp từ @KevinCruijssen. Đã lưu thêm 3 byte nhờ @FryAmTheEggman. Giải trình:

<
10*T

Thay thế mỗi cái <bằng 10 Ts.

+`^(.*)¶
60*$1

Lấy dòng đầu tiên, nhân nó với 60 và thêm dòng tiếp theo. Sau đó lặp lại cho đến khi chỉ còn một dòng.

T

Đếm Ts.

Phiên bản 51 byte nhanh hơn:

%`^(<*)(T*).*
$.(10*$1$2
+`^(.+)¶(.+)
$.($1*60*_$2*

Hãy thử trực tuyến! Sử dụng phân tách dòng mới, nhưng liên kết bao gồm tiêu đề để sử dụng khoảng trắng thay vì thuận tiện. Giải trình:

%`^(<*)(T*).*
$.(10*$1$2

Ghép từng dòng riêng lẻ và đếm số Ts và 10 lần số <s. Điều này chuyển đổi mỗi dòng thành giá trị "60" chữ số cơ sở của nó.

+`^(.+)¶(.+)
$.($1*60*_$2*

Chuyển đổi cơ sở 60, chạy một dòng tại một thời điểm. Việc tính toán được thực hiện theo số thập phân cho tốc độ.

Bash (với sed và dc), 50 byte

sed 's/</A+/g
s/T/1+/g
s/ /60*/g
s/\\//g'|dc -ez?p

Đưa đầu vào được phân tách bằng không gian từ stdin, đầu ra thànhstdout

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

Giải trình

Sử dụng sed để chuyển đổi đầu vào với một loạt các biểu thức khớp thông thường cho đến khi, ví dụ, đầu vào <<<TT \ TTTTđã được chuyển đổi thành A+A+A+1+1+60*60*1+1+1+1+. Sau đó, đầu vào này được đưa đến dc bằng lệnh thực thi đầu vào rõ ràng ?, trước đó z(đẩy chiều dài ngăn xếp (0) đến ngăn xếp để chúng ta có một nơi nào đó để nối đất bổ sung) và tiếp theo là p(in).

J , 34 30 byte

60#.1#.^:2(10 1*'<T'=/])&>@cut

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

APL Dyalog, 35 32 byte

f←{⍵+('<T\ '⍳⍺)⌷10,1,0,59×⍵}/∘⌽0∘,

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

31 tại dzaima / APL

Noether , 55 byte

I~sL(si/~c{"<"=}{k10+~k}c{"T"=}{!k}c{" "=}{k60*~k}!i)kP

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

Cách tiếp cận tương tự như @Arnauld.

Than , 26 byte

≔⁰θＦＳ«≡ι ≦×⁶⁰θ<≦⁺χθT≦⊕θ»Ｉθ

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

≔⁰θ

Xóa kết quả.

ＦＳ«...»

Lặp lại các ký tự đầu vào. Các ≡lệnh được bọc trong một khối để ngăn chặn nó từ việc tìm kiếm một "mặc định" khối.

≡ι

Chuyển qua nhân vật hiện tại ...

 ≦×⁶⁰θ

nếu đó là một khoảng trắng thì nhân kết quả với 60 ...

<≦⁺χθ

nếu đó là một <thì thêm 10 vào kết quả ...

T≦⊕θ

nếu đó là một Tkết quả tăng lên.

Ｉθ

In kết quả.

R , 98 81 byte

(u=sapply(scan(,""),function(x,y=utf8ToInt(x))y%%3%*%(y%%6)))%*%60^(sum(u|1):1-1)

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

Vô lý dài do phân tích chuỗi.Cảm ơn Giusppe đã cạo 16 byte không cần thiết.

Xác định ygiá trị mã byte của đầu vào unicode vàR = y("T<\") = y("𒐕𒌋𒑊")

Quan sát điều đó R%%3 = 1,2,0và R%%6 = 1,5,0... vì vậyR%%3 * R%%6 = 1,10,0 !

Phần còn lại rất dễ dàng: tổng trên mỗi cột, sau đó chấm sản phẩm với sức mạnh giảm 60.

Ruby , 50 46 byte

->a{x=0;a.bytes{|c|x+=[59*x,10,0,1][c%9%5]};x}

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

Một cổng cơ bản của câu trả lời của Arnauld được cải thiện bởi GB cho -4 byte.

C (gcc) , 65 64 63 byte

f(s,o)char*s;{for(o=0;*s;s++)o+=*s>32?(93^*s)/9:o*59;return o;}

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

Java 8, 64 60 byte

a->{int r=0;for(int c:a)r+=c<33?r*59:c<63?10:84/c;return r;}

-4 byte nhờ @ceilingcat .

Hãy thử trực tuyến. Giải trình:

a->{            // Method with character-array parameter and integer return-type
  int r=0;      //  Result-integer, starting at 0
  for(int c:a)  //  Loop over each character `c` of the input-array
    r+=         //   Increase the result by:
       c<33?    //    Is the current character `c` a space:
        r*59    //     Increase it by 59 times itself
       :c<63?   //    Else-if it's a '<':
        10      //     Increase it by 10
       :c<85?   //    Else (it's a 'T' or '\'):
        84/c;   //     Increase it by 84 integer-divided by `c`,
                //     (which is 1 for 'T' and 0 for '\')
  return r;}    //  Return the result

Perl -F // -E, 39 byte

$w+=/</?10:/T/?1:/ /?59*$w:0for@F;say$w

Điều này đọc số được chuyển đổi từ STDIN.

Đây là giải pháp thiết yếu tương tự như được đưa ra bởi @Arnauld bằng cách sử dụng JavaScript.

F #, 128 byte

let s(v:string)=Seq.mapFoldBack(fun r i->i*Seq.sumBy(fun c->match c with|'<'->10|'T'->1|_->0)r,i*60)(v.Split ' ')1|>fst|>Seq.sum

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

Ungolfed nó sẽ trông như thế này:

let s (v:string) =
    Seq.mapFoldBack(fun r i ->
        i * Seq.sumBy(fun c ->
            match c with
                | '<' -> 10
                | 'T' ->1
                | _ -> 0
        ) r, 
        i * 60) (v.Split ' ') 1
    |> fst
    |> Seq.sum

Seq.mapFoldBackkết hợp Seq.mapvà Seq.foldBack.Seq.mapFoldBacklặp qua chuỗi ngược và xâu chuỗi giá trị tích lũy qua chuỗi (trong trường hợp này lài ).

Đối với mỗi phần tử trong chuỗi, số Babylon được tính (theo Seq.sumBy, ánh xạ mỗi ký tự thành một số và tính tổng kết quả) và sau đó nhân vớii .isau đó được nhân với 60 và giá trị này sau đó được chuyển đến mục tiếp theo trong chuỗi. Trạng thái ban đầu cho bộ tích lũy là 1.

Ví dụ: thứ tự của các cuộc gọi và kết quả Seq.mapFoldBackcho đầu vào <<<TT \ TTTTsẽ là:

(TTTT, 1)     -> (4, 60)
(\, 60)       -> (0, 3600)
(<<<TT, 3600) -> (115200, 216000)

Hàm sẽ trả về một tuple của seq<int>, int. Các fsthàm trả về mục đầu tiên trong tuple đó, vàSeq.sum hiện tổng hợp thực tế.

Tại sao không sử dụng Seq.mapihoặc tương tự?

Seq.mapiánh xạ từng phần tử trong chuỗi và cung cấp chỉ mục cho hàm ánh xạ. Từ đó bạn có thể làm 60 ** index(nơi** là toán tử nguồn trong F #).

Nhưng **yêu cầu floats, không phảiints , có nghĩa là bạn cần khởi tạo hoặc truyền tất cả các giá trị trong hàm thànhfloat . Toàn bộ chức năng sẽ trả về mộtfloat , mà (theo tôi) là một chút lộn xộn.

Sử dụng Seq.mapinó có thể được thực hiện như thế này cho 139 byte :

let f(v:string)=v.Split ' '|>Seq.rev|>Seq.mapi(fun i r->Seq.sumBy(fun c->match c with|'<'->10.0|'T'->1.0|_->0.0)r*(60.0**float i))|>Seq.sum

Tcl , 134 byte

proc B l {regsub {\\} $l 0 l
lmap c [lreverse $l] {incr s [expr 60**([incr i]-1)*([regexp -all < $c]*10+[regexp -all T $c])]}
expr $s}

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

Trong danh sách đảo ngược, tôi lặp lại tăng kết quả khi đếm <và T(với-all tùy chọn regrec) và tăng tự nhiên là lũy thừa 60.

Phiên bản chính xác (xem bình luận)

APL (Dyalog Extended) , 18 byte ^SBCS

Chức năng tiền tố ẩn danh.

60⊥10⊥¨≠'<T'∘⍧¨⍤⊆⊢

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

                  ⊢  the argument; "<<<TT \ TTTT"
       ≠             mask where different from space; [1,1,1,1,1,0,1,0,1,1,1,1]
                ⊆    enclose runs of 1; ["<<<TT","\","TTTT"]
               ⍤     on that
              ¨      for each one
             ⍧       Count the occurrences In it of the elements
            ∘        of the entire list
        '<T'         ["<","T"]; [[3,2],[0,0],[0,4]]
      ¨              for each one
   10⊥               evaluate as base-10 digits
60⊥                  evaluate as base-60 digits

05AB1E (di sản) , 10 byte

#Ç9%5BO60β

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

#               # split input on spaces
 Ç              # convert each character to its codepoint
  9%            # modulo 9 (maps 𒌋 to 5, 𒐕 to 1, 𒑊 to 0)
    5B          # convert each to base 5 (5 becomes 10, 0 and 1 unchanged)
      O         # sum each column
       60β      # convert from base 60

05AB1E , 11 byte

#Ç9%5B€O60β

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

Cùng một thuật toán, nhưng trong 05AB1E hiện đại Okhông hoạt động trên danh sách các số nguyên và danh sách hỗn hợp, vì vậy chúng ta cần €Othay thế.