ท้าทาย

ให้การแทน ASCII ของหมายเลข Babylonian เป็น input, ส่งออกตัวเลขในเลขอารบิคตะวันตก

ระบบตัวเลขของบาบิโลน

ชาวบาบิโลนนับอย่างไร ที่น่าสนใจคือพวกเขาใช้ระบบฐาน 60 พร้อมองค์ประกอบของระบบฐาน 10 ก่อนอื่นให้พิจารณาคอลัมน์หน่วยของระบบ:

ชาวบาบิโลนมีเพียงสามสัญลักษณ์: T(หรือถ้าคุณสามารถทำให้มัน:) 𒐕ซึ่งเป็นตัวแทน 1 และ<(หรือถ้าคุณสามารถทำให้มัน:) 𒌋ซึ่งเป็นตัวแทน 10 และ\(หรือถ้าคุณทำให้มัน:) 𒑊ซึ่งเป็นศูนย์

หมายเหตุ: ในทางเทคนิคแล้ว\(หรือ𒑊) ไม่ใช่ศูนย์ (เพราะชาวบาบิโลนไม่ได้มีความคิดเป็น 'ศูนย์') 'Zero' ถูกประดิษฐ์ขึ้นในภายหลังดังนั้นจึง\มีการเพิ่มสัญลักษณ์ตัวยึดตำแหน่งในภายหลังเพื่อป้องกันความกำกวม อย่างไรก็ตามสำหรับวัตถุประสงค์ของการท้าทายนี้ก็ถือว่าเพียงพอแล้วที่จะ\เป็นศูนย์

ดังนั้นในแต่ละคอลัมน์คุณเพียงเพิ่มมูลค่าของสัญลักษณ์เช่น:

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

จะไม่มีมากกว่าห้า<หรือมากกว่าเก้าTในแต่ละคอลัมน์ \จะปรากฏอยู่คนเดียวในคอลัมน์เสมอ

ตอนนี้เราจำเป็นต้องขยายเพื่อเพิ่มคอลัมน์เพิ่มเติม วิธีนี้ทำงานเหมือนกับฐานหกสิบอื่น ๆ ทุกประการที่คุณคูณค่าของคอลัมน์ขวาสุดด้วย , หนึ่งทางซ้าย , หนึ่งทางซ้ายเป็นต้น จากนั้นคุณจะเพิ่มมูลค่าของแต่ละรายการเพื่อรับค่าของตัวเลข$60^0$$60^1$$60^2$

คอลัมน์จะถูกคั่นด้วยช่องว่างเพื่อป้องกันความกำกวม

ตัวอย่างบางส่วน:

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

กฎระเบียบ

• คุณมีอิสระที่จะรับอินพุต ASCII ( T<\) หรืออินพุต Unicode ( 𒐕𒌋𒑊)
• จำนวนที่ป้อนจะต่ำกว่า$10^7$
• <เสมอจะไปทางซ้ายของTในแต่ละคอลัมน์
• \ จะปรากฏอยู่คนเดียวในคอลัมน์เสมอ

การชนะ

รหัสที่สั้นที่สุดในหน่วยไบต์ชนะ

JavaScript (ES6), 44 ไบต์

รับอินพุตเป็นอาร์เรย์ของอักขระ ASCII

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

ลองออนไลน์!

อย่างไร?

ระบบตัวเลขของชาวบาบิโลนนั้นถูกมองว่าเป็นภาษา 4 คำสั่งที่ทำงานด้วยการลงทะเบียนครั้งเดียว - เรียกมันว่าแอคคูมูเลเตอร์

เริ่มต้นด้วยอักขระแต่ละตัวในอาร์เรย์อินพุตจะปรับเปลี่ยนการสะสมดังนี้:c a $k=0$$c$$a$$k$

• space: คูณด้วย60 (ใช้งานเป็น: เพิ่ม59 kถึงk )$k$$60$$59k$$k$
• <: เพิ่มถึง$10$$k$
• T: เพิ่มค่า$k$
• \: ไม่ทำอะไร; นี่คือNOPคำสั่งของภาษานี้ (นำไปใช้เป็น: เพิ่มถึงk )$0$$k$

C (gcc) , 140 138 136 ไบต์

• ที่บันทึกไว้สองไบต์ขอบคุณที่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;}

ลองออนไลน์!

Perl 6 , 39 ไบต์

-3 ไบต์ขอบคุณ nwellnhof

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

ลองออนไลน์!

ใช้อักขระตัวพิมพ์ใหญ่

คำอธิบาย:

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

เยลลี่ ,  13  12 ไบต์

ḲO%7C%13§ḅ60

ลิงก์ monadic ยอมรับรายการของอักขระที่ให้จำนวนเต็ม

ลองออนไลน์!

อย่างไร?

Ḳ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

อีก 12: ḲO⁽¡€%:5§ḅ60( ⁽¡€เป็น1013ดังนั้น modulos นี้1013โดยOค่า rdinal รับ53, 5และ1สำหรับ<, T, \ตามลำดับจากนั้นดำเนินการจำนวนเต็มหาร:โดย5จะได้รับ10, 1และ0)

05AB1E , 13 ไบต์

8740|Ç%4/O60β

ลองออนไลน์!

เพื่อชดเชยว่าฉันขี้เกียจกับคำตอบ Jelly ของฉันได้อย่างไรนี่คือการส่งใน 05AB1E xD

Python 2 , 96 93 87 85 ไบต์

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

ลองออนไลน์!

ที่บันทึกไว้:

• -1 ไบต์ขอบคุณ Mr. Xcoder
• -4 ไบต์ขอบคุณ Poon Levi
• -2 ไบต์ขอบคุณ Matthew Jensen

Excel VBA ขนาด 121 ไบต์

จำกัด ไว้ที่ Office แบบ 32 บิตซึ่ง^ทำหน้าที่เป็นLongLongตัวอักษรประเภทในรุ่น 64 บิต

รับอินพุตจากเซลล์A1และเอาต์พุตไปยังหน้าต่าง 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

Ungolfed และแสดงความคิดเห็น

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 ไบต์

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

ลองออนไลน์!

แก้ไข: -3 ไบต์ขอบคุณngn

'\ T<'⍳แทนที่อักขระด้วยตัวเลข (ตำแหน่งของพวกเขาในค่าคงที่ของสตริง) และ⌽ย้อนกลับอินพุตดังนั้น 'หลัก' ที่สำคัญที่สุดจะคงอยู่ สิ่งนี้ช่วยให้+\2=สามารถนับจำนวนกำลังไฟที่ต้องการ 60 (ใช้โดย60*) โดยการนับจำนวนครั้งที่มีช่องว่าง (ดัชนี 2 ในค่าคงที่สตริง)

⌊10*⍵-3ให้พลังที่ต้องการเป็นสิบสำหรับตัวละครแต่ละตัว ลำดับของอักขระในค่าคงที่สตริงและออฟเซ็ต -3 ทำให้เกิด '\' และช่องว่างเพื่อไปยังจำนวนลบทำให้เกิดเศษส่วนเมื่ออักขระเหล่านั้นถูกยกกำลัง 10 ทำให้สามารถกำจัด⌊ได้

ทั้งหมดที่เราต้องทำตอนนี้คือคูณตัวเลขอำนาจของ-10 โดยอำนาจของ 60 +/ค่าสถานที่และสรุปจำนวนมากขึ้นด้วย

Python 2 , 62 ไบต์

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

ลองออนไลน์!

นี้จะใช้เทคนิคจากคำตอบของ Arnauld

Canvas , 20 17 16 ไบต์

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

ลองที่นี่!

คำอธิบาย:

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 ตัวอักษร, 56 ไบต์

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

ทดสอบกับการตรวจสอบประเภท:

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

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

ผลลัพธ์แต่ละประเภทคือตัวเลข

JavaScript (Node.js) , 122 114 107 106 83 ไบต์

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

ลองออนไลน์!

ฉันหมกมุ่นอยู่กับการทำงานของอาเรย์แบบ "functional-style" ใช้ ASCII input เท่าที่ฉันสามารถบอกได้ JS ไม่ค่อยเก่งในการรับ charcodes golfily

ฉันเก็บเรื่องนี้ไว้เพื่อประโยชน์ของลูกหลาน แต่นี่เป็นวิธีแก้ปัญหาที่ไร้เดียงสา / เป็นใบ้ฉันขอแนะนำให้คุณดูคำตอบของ Arnauldซึ่งน่าสนใจกว่าการใช้ความท้าทาย

Retina , 29 26 23 ไบต์

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

ลองออนไลน์! ใช้การขึ้นบรรทัดใหม่ แต่ลิงก์มีส่วนหัวเพื่อใช้ช่องว่างแทนเพื่อความสะดวก แก้ไข: บันทึกแล้ว 3 ไบต์ด้วยความช่วยเหลือจาก @KevinCruijssen บันทึกอีก 3 ไบต์ด้วย @FryAmTheEggman คำอธิบาย:

<
10*T

แทนที่แต่ละรายการ<ด้วย 10 Tวิ

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

ใช้บรรทัดแรกคูณด้วย 60 และเพิ่มบรรทัดถัดไป จากนั้นทำซ้ำจนกว่าจะมีเพียงหนึ่งบรรทัดที่เหลือ

T

นับTs

รุ่นที่เร็วกว่า 51 ไบต์:

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

ลองออนไลน์! ใช้การขึ้นบรรทัดใหม่ แต่ลิงก์มีส่วนหัวเพื่อใช้ช่องว่างแทนเพื่อความสะดวก คำอธิบาย:

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

ตรงกับแต่ละบรรทัดรายบุคคลและนับจำนวนของTs และ 10 เท่าของจำนวนของ<s สิ่งนี้จะแปลงแต่ละบรรทัดให้เป็นค่าฐาน "60 หลัก"

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

การแปลงฐาน 60 วิ่งครั้งละหนึ่งบรรทัด การคำนวณจะทำในรูปแบบทศนิยมสำหรับความเร็ว

Bash (พร้อม sed และ dc) 50 ไบต์

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

ใช้อินพุตที่คั่นด้วยช่องว่างจากstdinเอาต์พุตไปยังstdout

ลองออนไลน์!

คำอธิบาย

ใช้ sed ที่จะเปลี่ยนการป้อนข้อมูลที่มีพวงของการแข่งขันการแสดงออกปกติจนยกตัวอย่างเช่นการป้อนข้อมูลที่ได้รับการเปลี่ยนไป<<<TT \ TTTT A+A+A+1+1+60*60*1+1+1+1+จากนั้นอินพุตนี้จะถูกป้อนไปยัง dc พร้อมกับคำสั่งการดำเนินการอินพุตอย่างชัดเจน?นำหน้าด้วยz(ดันความยาวสแต็ก (0) ไปยังสแต็กเพื่อให้เรามีที่ที่จะเพิ่มการเพิ่ม) และตามด้วยp(พิมพ์)

J , 34 30 ไบต์

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

ลองออนไลน์!

Dyalog APL, 35 32 ไบต์

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

ลองออนไลน์!

31ใน dzaima / APL

Noether , 55 ไบต์

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

ลองออนไลน์!

เช่นเดียวกับ @Arnauld

ถ่าน 26 ไบต์

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

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด คำอธิบาย:

≔⁰θ

ล้างผลลัพธ์

ＦＳ«...»

วนซ้ำอักขระที่ป้อนเข้า ≡คำสั่งถูกห่อในบล็อกเพื่อป้องกันไม่ให้มันจากการหาบล็อก "เริ่มต้น"

≡ι

สลับไปที่อักขระปัจจุบัน ...

 ≦×⁶⁰θ

ถ้ามันเป็นช่องว่างให้คูณผลลัพธ์ด้วย 60 ...

<≦⁺χθ

ถ้ามันเป็น<แล้วเพิ่ม 10 ผล ...

T≦⊕θ

ถ้ามันเป็นTผลลัพธ์ที่เพิ่มขึ้นแล้ว

Ｉθ

พิมพ์ผลลัพธ์

R , 98 81 ไบต์

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

ลองออนไลน์!

ยาวขันเนื่องจากการแยกสตริง ขอบคุณ Giusppe สำหรับการกำจัด 16 ไบต์ที่ไม่จำเป็น

กำหนดyค่า bytecode ของอินพุต unicode และR = y("T<\") = y("𒐕𒌋𒑊")

สังเกตสิ่งนั้นR%%3 = 1,2,0และR%%6 = 1,5,0... อย่างนั้นR%%3 * R%%6 = 1,10,0!

ส่วนที่เหลือเป็นเรื่องง่าย: ผลรวมต่อคอลัมน์จากนั้นผลิตภัณฑ์ดอทที่มีพลังลดลง 60

Ruby , 50 46 ไบต์

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

ลองออนไลน์!

พอร์ตพื้นฐานของคำตอบของ Arnauldปรับปรุงโดย GB สำหรับ -4 ไบต์

C (gcc) , 65 64 63 ไบต์

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

ลองออนไลน์!

ชวา 8, 64 60 ไบต์

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

-4 ไบต์ขอบคุณที่@ceilingcat

ลองออนไลน์ คำอธิบาย:

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 ไบต์

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

นี่เป็นการอ่านค่าที่แปลงจาก STDIN

นี่เป็นสิ่งสำคัญซึ่งเป็นโซลูชันเดียวกับที่กำหนดโดย @Arnauld โดยใช้ JavaScript

F #, 128 ไบต์

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

ลองออนไลน์!

Ungolfed มันจะมีลักษณะเช่นนี้:

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.mapFoldBackรวมและSeq.map วนซ้ำผ่านลำดับไปข้างหลังและเธรดค่าตัวสะสมผ่านลำดับ (ในกรณีนี้Seq.foldBackSeq.mapFoldBacki )

สำหรับองค์ประกอบในแต่ละลำดับจำนวนชาวบาบิโลนคำนวณ (โดยSeq.sumByที่ตัวละครแต่ละตัวแผนที่ไปยังหมายเลขและรวมผล) iและคูณด้วยแล้วiจะถูกคูณด้วย 60 และค่านี้จะถูกส่งผ่านไปยังรายการถัดไปตามลำดับ สถานะเริ่มต้นสำหรับการสะสมคือ 1

ตัวอย่างเช่นลำดับการโทรและผลลัพธ์Seq.mapFoldBackสำหรับอินพุต<<<TT \ TTTTจะเป็น:

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

ฟังก์ชั่นจะกลับ tuple seq<int>, intของ fstฟังก์ชันส่งกลับรายการแรกใน tuple นั้นและSeq.sumไม่ข้อสรุปที่เกิดขึ้นจริง

ทำไมไม่ใช้Seq.mapiหรือคล้ายกัน?

Seq.mapiแผนที่แต่ละองค์ประกอบในลำดับและจัดทำดัชนีไปยังฟังก์ชั่นการทำแผนที่ จากตรงนั้นคุณสามารถทำได้60 ** index(ที่ไหน**คือผู้ให้บริการพลังงานใน F #)

แต่**ต้องfloatsไม่ซึ่งหมายความว่าคุณจะต้องเริ่มใช้อย่างใดอย่างหนึ่งหรือโยนค่าทั้งหมดในการทำงานเป็นints floatฟังก์ชั่นทั้งหมดจะกลับมาfloatซึ่ง (ในความคิดของฉัน) จะยุ่งเล็กน้อย

การใช้งานSeq.mapiสามารถทำได้เช่นนี้เป็นเวลา139 ไบต์ :

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 ไบต์

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}

ลองออนไลน์!

ในรายการที่กลับรายการฉันวนรอบการเพิ่มผลลัพธ์ในการนับ<และT(พร้อม-allตัวเลือก regexp) และการเพิ่มค่าเป็นธรรมชาติเท่ากับกำลัง 60

รุ่นที่ถูกต้อง (ดูความคิดเห็น)

APL (Dyalog Extended) , 18 ไบต์^SBCS

ฟังก์ชันนำหน้าเงียบโดยไม่ระบุชื่อ

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

ลองออนไลน์!

                  ⊢  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 (ดั้งเดิม) 10 ไบต์

#Ç9%5BO60β

ลองออนไลน์!

#               # 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 ไบต์

#Ç9%5B€O60β

ลองออนไลน์!

อัลกอริทึมเดียวกัน แต่ใน 05AB1E ที่ทันสมัยOไม่สามารถใช้งานได้กับรายการของ int และรายการที่ผสมกันดังนั้นเราจึงต้องการ€Oแทน