Tantangan

Diberikan representasi ASCII dari nomor Babel sebagai input, output angka dalam angka Arab Barat.

Sistem Angka Babilonia

Bagaimana orang Babilonia menghitung? Menariknya, mereka menggunakan sistem Base 60 dengan elemen sistem Base 10. Pertama mari kita perhatikan kolom unit sistem:

Bangsa Babilonia hanya memiliki tiga simbol: T(atau, jika Anda dapat menerjemahkannya:) 𒐕yang mewakili 1, dan <(atau, jika Anda dapat menerjemahkannya:) 𒌋yang mewakili 10, dan \(atau, jika Anda menerjemahkannya:) 𒑊yang mewakili nol.

Catatan: Secara teknis, \(atau 𒑊) bukan nol (karena orang Babel tidak memiliki gagasan 'nol'). 'Nol' ditemukan kemudian, demikian \juga simbol placeholder ditambahkan kemudian untuk mencegah ambiguitas. Namun, untuk keperluan tantangan ini, cukup untuk dianggap \sebagai nol

Jadi, di setiap kolom Anda hanya menambahkan nilai simbol, misalnya:

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

Tidak akan ada lebih dari lima <atau lebih dari sembilan Tdi setiap kolom. \akan selalu muncul sendiri di kolom.

Sekarang, kita perlu memperluas ini untuk menambahkan lebih banyak kolom. Ini bekerja persis sama dengan basis enam puluh lainnya, di mana Anda mengalikan nilai kolom paling kanan dengan , yang ke kiri dengan 60 1 , yang ke kiri dengan 60 2 dan seterusnya. Anda kemudian menjumlahkan nilai masing-masing untuk mendapatkan nilai angka.$60^0$$60^1$$60^2$

Kolom akan dipisahkan oleh spasi untuk mencegah ambiguitas.

Beberapa contoh:

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

Aturan

• Anda bebas menerima input ASCII ( T<\) atau input Unicode ( 𒐕𒌋𒑊)
• Nomor yang dimasukkan akan selalu di bawah $10^7$
• The <s akan selalu ke kiri Ts di setiap kolom
• \ akan selalu muncul sendiri di kolom

Kemenangan

Kode terpendek dalam byte menang.

JavaScript (ES6), 44 byte

Mengambil input sebagai array karakter ASCII.

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

Cobalah online!

Bagaimana?

Sistem Angka Babilonia dapat dilihat sebagai bahasa 4-instruksi yang bekerja dengan satu register - sebut saja akumulator.

Dimulai dengan , setiap karakter c dalam larik input a memodifikasi akumulator k sebagai berikut:$k=0$$c$$a$$k$

• space: kalikan dengan 60 (diimplementasikan sebagai: tambahkan 59 k ke k )$k$$60$$59k$$k$
• <: tambahkan ke $10$$k$
• T: increment $k$
• \: tidak melakukan apapun; ini adalah NOPinstruksi dari bahasa ini (diimplementasikan sebagai: tambah hingga k )$0$$k$

C (gcc) , 140 138 136 byte

• Disimpan dua byte berkat ceilingcat .

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;}

Cobalah online!

Perl 6 , 39 byte

-3 byte terima kasih kepada nwellnhof

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

Cobalah online!

Menggunakan karakter paku.

Penjelasan:

{                                     }   # 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

Jelly ,  13  12 byte

ḲO%7C%13§ḅ60

Tautan monadik yang menerima daftar karakter yang menghasilkan bilangan bulat.

Cobalah online!

Bagaimana?

Ḳ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

Lain 12: ḲO⁽¡€%:5§ḅ60( ⁽¡€adalah 1013, jadi ini modulos 1013dengan Onilai-nilai rdinal mendapatkan 53, 5dan 1untuk <, T, \masing-masing kemudian melakukan bilangan bulat divisi, :dengan 5mendapatkan 10, 1dan 0)

05AB1E , 13 byte

8740|Ç%4/O60β

Cobalah online!

Untuk menebus betapa malasnya saya dengan jawaban Jelly saya, berikut ini adalah kiriman di 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]))

Cobalah online!

Disimpan:

• -1 byte, terima kasih kepada Tn. Xcoder
• -4 byte, terima kasih untuk Poon Levi
• -2 byte, terima kasih kepada Matthew Jensen

Excel VBA, 121 byte

Terbatas untuk Office 32-Bit yang ^berfungsi sebagai LongLongtipe literal dalam versi 64-Bit

Membawa input dari sel A1dan output ke jendela langsung vbe.

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

Tidak Disatukan dan Dikomentari

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

Dyalog APL , 33 30 byte

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

Cobalah online!

Edit: -3 byte terima kasih kepada ngn

'\ T<'⍳mengganti karakter dengan angka (posisinya di string konstan), dan ⌽membalikkan input sehingga 'digit' yang paling signifikan adalah yang terakhir. Hal ini memungkinkan +\2=untuk menjaga hitungan berjalan dari kekuatan yang diinginkan dari 60 (diterapkan oleh 60*) dengan menghitung berapa kali spasi (indeks 2 dalam konstanta string) ditemui.

⌊10*⍵-3memberikan kekuatan sepuluh yang diinginkan untuk setiap karakter. Urutan karakter dalam konstanta string dan -3 offset menyebabkan '\' dan ruang untuk pergi ke angka negatif, menghasilkan pecahan ketika karakter tersebut dinaikkan ke kekuatan 10, yang memungkinkan mereka dihilangkan oleh ⌊.

Yang harus kita lakukan sekarang adalah mengalikan kekuatan-dari-10 digit dengan nilai-nilai kekuatan-dari-60 tempat dan menjumlahkannya +/.

Python 2 , 62 byte

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

Cobalah online!

Ini menggunakan teknik dari jawaban Arnauld .

Kanvas , 20 17 16 byte

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

Coba di sini!

Penjelasan:

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 karakter, 56 byte

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

beberapa tes dengan jenis cek:

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

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

Setiap jenis hasil adalah angka.

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)

Cobalah online!

Saya sedikit terobsesi dengan operasi array "gaya fungsional", menggunakan input ASCII, sejauh yang saya tahu, JS tidak terlalu pandai mendapatkan kode-kode golfily

Saya menyimpan ini untuk anak cucu, tetapi ini adalah solusi yang naif / bodoh, saya sarankan Anda memeriksa jawaban Arnauld yang jauh lebih menarik dari implementasi tantangan

Retina , 29 26 23 byte

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

Cobalah online! Menggunakan pemisahan baris baru, tetapi tautan menyertakan tajuk untuk menggunakan spasi sebagai gantinya untuk kenyamanan. Sunting: Disimpan 3 byte dengan bantuan dari @KevinCruijssen. Menyimpan 3 byte lebih lanjut berkat @FryAmTheEggman. Penjelasan:

<
10*T

Ganti masing <- masing dengan 10 Tdetik.

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

Ambil baris pertama, kalikan dengan 60, dan tambahkan baris berikutnya. Kemudian ulangi sampai hanya ada satu baris yang tersisa.

T

Hitung Ts.

Versi 51 byte yang lebih cepat:

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

Cobalah online! Menggunakan pemisahan baris baru, tetapi tautan menyertakan tajuk untuk menggunakan spasi sebagai gantinya untuk kenyamanan. Penjelasan:

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

Cocokkan setiap baris satu per satu, dan hitung jumlah Ts dan 10 kali jumlah <s. Ini mengubah setiap baris menjadi nilai "digit" basis-60.

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

Basis konversi 60, menjalankan baris pada suatu waktu. Perhitungan dilakukan dalam desimal untuk kecepatan.

Bash (dengan sed dan dc), 50 byte

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

Membawa input yang dibatasi ruang stdin, dari menjadistdout

Cobalah online!

Penjelasan

Menggunakan sed untuk mengubah input dengan sekelompok kecocokan ekspresi reguler hingga, misalnya, input <<<TT \ TTTTtelah ditransformasikan menjadi A+A+A+1+1+60*60*1+1+1+1+. Kemudian input ini diumpankan ke dc dengan perintah eksekusi input eksplisit ?, didahului oleh z(mendorong panjang stack (0) ke stack sehingga kita memiliki tempat untuk menambahkan tambahan) dan diikuti oleh p(cetak).

J , 34 30 byte

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

Cobalah online!

Dyalog APL, 35 32 byte

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

Cobalah online!

31 dalam dzaima / APL

Noether , 55 byte

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

Cobalah online!

Pendekatan yang sama dengan @Arnauld.

Arang , 26 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan:

≔⁰θ

Kosongkan hasilnya.

ＦＳ«...»

Ulangi karakter input. The ≡perintah dibungkus dalam blok untuk mencegah menemukan "default" blok.

≡ι

Beralih dari karakter saat ini ...

 ≦×⁶⁰θ

jika itu spasi maka kalikan hasilnya dengan 60 ...

<≦⁺χθ

jika a <maka tambahkan 10 ke hasilnya ...

T≦⊕θ

jika itu Tmaka kenaikan hasilnya.

Ｉθ

Cetak hasilnya.

R , 98 81 byte

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

Cobalah online!

Sangat panjang karena penguraian string. Terima kasih Giusppe untuk mencukur 16 byte yang tidak perlu.

Tentukan ynilai bytecode dari input unicode danR = y("T<\") = y("𒐕𒌋𒑊")

Amati itu R%%3 = 1,2,0dan R%%6 = 1,5,0... jadi R%%3 * R%%6 = 1,10,0!

Sisanya mudah: jumlah per kolom, kemudian produk-titik dengan kekuatan menurun 60.

Ruby , 50 46 byte

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

Cobalah online!

Port dasar jawaban Arnauld ditingkatkan oleh GB untuk -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;}

Cobalah online!

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 terima kasih kepada @ceilingcat .

Cobalah online. Penjelasan:

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

Ini membaca nomor yang akan dikonversi dari STDIN.

Ini penting untuk solusi yang sama seperti yang diberikan oleh @Arnauld menggunakan 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

Cobalah online!

Ungolfed akan terlihat seperti ini:

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.mapFoldBackmenggabungkan Seq.mapdan Seq.foldBack. Seq.mapFoldBackiterates melalui urutan mundur, dan utas nilai akumulator melalui urutan (dalam hal ini, i).

Untuk setiap elemen dalam urutan, angka Babel dihitung (oleh Seq.sumBy, yang memetakan setiap karakter ke angka dan total hasilnya) dan kemudian dikalikan dengan i. ikemudian dikalikan dengan 60, dan nilai ini kemudian diteruskan ke item berikutnya dalam urutan. Keadaan awal untuk akumulator adalah 1.

Misalnya, urutan panggilan dan hasil Seq.mapFoldBackinput <<<TT \ TTTTadalah:

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

Fungsi akan mengembalikan tuple seq<int>, int. The fstmengembalikan fungsi item pertama dalam tuple itu, dan Seq.summelakukan penjumlahan yang sebenarnya.

Mengapa tidak menggunakan Seq.mapiatau serupa?

Seq.mapimemetakan setiap elemen dalam urutan, dan menyediakan indeks ke fungsi pemetaan. Dari sana Anda bisa melakukannya 60 ** index(di mana **operator daya di F #).

Tetapi **membutuhkan floats, tidak ints, yang berarti bahwa Anda perlu menginisialisasi atau melemparkan semua nilai dalam fungsi sebagai float. Seluruh fungsi akan mengembalikan a float, yang (menurut saya) agak berantakan.

Menggunakannya Seq.mapidapat dilakukan seperti ini untuk 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}

Cobalah online!

Dalam daftar terbalik, saya loop menambah hasil dalam penghitungan <dan T(dengan -allopsi regexp) dan menambah kekuatan alami 60.

Versi yang benar (lihat komentar)

APL (Dyalog Extended) , 18 byte ^SBCS

Fungsi awalan diam-diam anonim.

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

Cobalah online!

                  ⊢  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 (warisan) , 10 byte

#Ç9%5BO60β

Cobalah online!

#               # 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β

Cobalah online!

Algoritma yang sama, tetapi di 05AB1E modern Otidak bekerja pada daftar int dan daftar campuran, jadi kita perlu €Osebagai gantinya.