Herausforderung

Geben Sie bei einer ASCII-Darstellung einer babylonischen Zahl als Eingabe die Zahl in arabischen Ziffern aus.

Babylonisches Zahlensystem

Wie haben die Babylonier gezählt? Interessanterweise verwendeten sie ein Base 60-System mit einem Element eines Base 10-Systems. Betrachten wir zunächst die Einheitenspalte des Systems:

Die Babylonier hatten nur drei Symbole: T(oder, wenn Sie es rendern können:), 𒐕die 1 repräsentierten, und <(oder, wenn Sie es rendern können:), 𒌋die 10 repräsentierten, und \(oder, wenn Sie es rendern:), 𒑊die Null repräsentierten.

Hinweis: Technisch gesehen ist \(oder 𒑊) nicht Null (weil die Babylonier keine Null hatten). 'Zero' wurde später erfunden, und \ein Platzhaltersymbol wurde später hinzugefügt, um Mehrdeutigkeiten zu vermeiden. Für die Zwecke dieser Herausforderung ist es jedoch ausreichend, sie \als Null zu betrachten

Also addieren Sie in jeder Spalte einfach den Wert der Symbole, zB:

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

Es werden niemals mehr als fünf <oder mehr als neun Tin jeder Spalte sein. \wird immer alleine in der Spalte angezeigt.

Jetzt müssen wir dies erweitern, um weitere Spalten hinzuzufügen. Dies funktioniert genauso wie bei jeder anderen Basis-Sechzig, bei der Sie den Wert der am weitesten rechts stehenden Spalte mit , den Wert links mit 60 1 , den Wert links mit 60 2 usw. multiplizieren . Sie addieren dann den Wert von jedem, um den Wert der Zahl zu erhalten.$60^0$$60^1$$60^2$

Spalten werden durch Leerzeichen getrennt, um Mehrdeutigkeiten zu vermeiden.

Einige Beispiele:

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

Regeln

• Sie können entweder ASCII-Eingaben ( T<\) oder Unicode-Eingaben ( 𒐕𒌋𒑊) akzeptieren.
• Die eingegebene Nummer liegt immer unter $10^7$
• Das <s steht Tin jeder Spalte immer links vom s
• \ wird immer alleine in einer Spalte angezeigt

Gewinnen

Kürzester Code in Bytes gewinnt.

JavaScript (ES6), 44 Byte

Übernimmt die Eingabe als Array von ASCII-Zeichen.

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

Probieren Sie es online!

Wie?

Das babylonische Zahlensystem kann als eine 4-Anweisungssprache angesehen werden, die mit einem einzigen Register arbeitet - nennen wir es den Akkumulator.

Beginnend mit modifiziert jedes Zeichen c im Eingabearray a den Akkumulator k wie folgt:$k=0$$c$$a$$k$

• space: multipliziere mit 60 (implementiert als: addiere 59 k zu k )$k$$60$$59k$$k$
• <: addiere zu $10$$k$
• T: Inkrement $k$
• \: nichts tun; Dies ist die NOPAnweisung dieser Sprache (implementiert als: addiere zu k )$0$$k$

C (GCC) , 140 138 136 Bytes

• Dank ceilingcat zwei Bytes gespart .

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

Probieren Sie es online!

Perl 6 , 39 Bytes

-3 bytes dank nwellnhof

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

Probieren Sie es online!

Verwendet die Keilschriftzeichen.

Erläuterung:

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

ḲO%7C%13§ḅ60

Ein monadischer Link, der eine Liste von Zeichen akzeptiert, die eine Ganzzahl ergibt.

Probieren Sie es online!

Wie?

Ḳ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

Weitere 12: ḲO⁽¡€%:5§ḅ60( ⁽¡€ist 1013, so dass diese modulos 1013durch die Ordinal Werte bekommen 53, 5und 1für <, T, \jeweils dann führt Integer - Division, :durch 5zu bekommen 10, 1und 0)

05AB1E , 13 Bytes

8740|Ç%4/O60β

Probieren Sie es online!

Um nachzuholen, wie faul ich mit meiner Gelee-Antwort gewesen bin, ist hier eine Einreichung in 05AB1E xD.

Python 2 , 96 93 87 85 Bytes

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

Probieren Sie es online!

Gerettet:

• -1 Byte, danke an Herrn Xcoder
• -4 Bytes, danke an Poon Levi
• -2 Bytes, danke an Matthew Jensen

Excel VBA, 121 Byte

Zu 32-Bit - Office als offenes ^dient als LongLongTyp wörtlichen in 64-Bit - Versionen

Übernimmt Eingaben von der Zelle A1und Ausgaben in das VBE-Direktfenster.

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 und Kommentiert

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 Bytes

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

Probieren Sie es online!

Edit: -3 Bytes dank ngn

'\ T<'⍳ Ersetzt die Zeichen durch Zahlen (ihre Position in der Zeichenfolgenkonstante) und ⌽ kehrt die Eingabe um, sodass die wichtigsten 'Ziffern' die letzten sind. Dies ermöglicht +\2=es, eine laufende Zählung der gewünschten Leistung von 60 (angewendet von 60*) aufrechtzuerhalten, indem gezählt wird, wie oft ein Leerzeichen (Index 2 in der Zeichenfolge konstant) angetroffen wird.

⌊10*⍵-3gibt für jedes Zeichen die gewünschte Zehnerpotenz an. Die Reihenfolge der Zeichen in der String-Konstante und der -3-Versatz bewirken, dass '\' und Leerzeichen auf negative Zahlen gesetzt werden, was zu Brüchen führt, wenn diese Zeichen auf die Zehnerpotenz angehoben werden ⌊.

Jetzt müssen wir nur noch die Zehnerpotenzen mit den 60erpotenzen multiplizieren und das Los mit zusammenfassen +/.

Python 2 , 62 Bytes

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

Probieren Sie es online!

Dies verwendet die Technik von Arnauld's Antwort .

Canvas , 20 17 16 Bytes

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

Probieren Sie es hier aus!

Erläuterung:

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 Zeichen, 56 Byte

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

einige Tests mit Typprüfung:

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

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

Jedes Typenergebnis ist eine Zahl.

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)

Probieren Sie es online!

Ich bin ein bisschen besessen von "funktionalen" Array-Operationen, benutze ASCII-Eingabe, soweit ich das beurteilen kann, ist JS nicht sehr gut darin, Zeichencodes golfen zu können

Ich behalte das für die Nachwelt, aber das ist eine naive / blöde Lösung. Ich schlage vor, Sie sehen sich Arnauld's Antwort an, was für die Umsetzung der Herausforderung weitaus interessanter ist

Retina , 29 26 23 Bytes

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

Probieren Sie es online! Verwendet Zeilenumbrüche, der Link enthält jedoch einen Header, um Leerzeichen zu verwenden. Bearbeiten: 3 Bytes mit Hilfe von @KevinCruijssen gespeichert. Weitere 3 Bytes dank @FryAmTheEggman gespeichert. Erläuterung:

<
10*T

Jeweils <durch 10 Ts ersetzen .

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

Nehmen Sie die erste Zeile, multiplizieren Sie sie mit 60 und fügen Sie die nächste Zeile hinzu. Dann wiederholen, bis nur noch eine Zeile übrig ist.

T

Zähle die Ts.

Schnellere 51-Byte-Version:

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

Probieren Sie es online! Verwendet Zeilenumbrüche, aber der Link enthält Header, um Leerzeichen zu verwenden. Erläuterung:

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

Ordnen Sie jede Zeile einzeln zu und zählen Sie die Anzahl Ts und das Zehnfache der Anzahl <s. Dies wandelt jede Zeile in ihren "stelligen" Basis-60-Wert um.

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

Base 60-Konvertierung, wobei jeweils eine Zeile ausgeführt wird. Die Berechnung erfolgt für die Geschwindigkeit dezimal.

Bash (mit sed und dc), 50 Bytes

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

Übernimmt durch Leerzeichen getrennte Eingaben von stdin, Ausgaben bisstdout

Probieren Sie es online!

Erläuterung

Verwendet sed, um die Eingabe mit einer Reihe von Übereinstimmungen mit regulären Ausdrücken zu transformieren, bis beispielsweise die Eingabe <<<TT \ TTTTin transformiert wurde A+A+A+1+1+60*60*1+1+1+1+. Dann wird diese Eingabe in DC mit dem expliziten Eingangsausführungsbefehl zugeführt ?, mit vorangestelltem z(drückt die Stapellänge (0) auf den Stapel , so dass wir die Zugabe müssen irgendwo Masse) und gefolgt von p(Druck).

J , 34-30 Bytes

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

Probieren Sie es online!

Dyalog APL, 35 32 Bytes

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

Probieren Sie es online!

31 in dzaima / APL

Noether , 55 Bytes

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

Probieren Sie es online!

Gleicher Ansatz wie @Arnauld.

Holzkohle , 26 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

≔⁰θ

Löschen Sie das Ergebnis.

ＦＳ«...»

Schleife über die eingegebenen Zeichen. Der ≡Befehl wird in einen Block eingeschlossen, um zu verhindern, dass er einen "Standard" -Block findet.

≡ι

Aktuellen Charakter umschalten ...

 ≦×⁶⁰θ

Wenn es ein Leerzeichen ist, multiplizieren Sie das Ergebnis mit 60 ...

<≦⁺χθ

Wenn es ein ist, <dann addiere 10 zum Ergebnis ...

T≦⊕θ

Wenn es ein Tist, erhöhen Sie das Ergebnis.

Ｉθ

Drucken Sie das Ergebnis.

R , 98 81 Bytes

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

Probieren Sie es online!

Lächerlich lang wegen String-Analyse. Vielen Dank an Giusppe für das Abschneiden von 16 unnötigen Bytes.

Definieren y den Bytecode-Wert der Unicode-Eingabe undR = y("T<\") = y("𒐕𒌋𒑊")

Beobachten Sie das R%%3 = 1,2,0und R%%6 = 1,5,0... soR%%3 * R%%6 = 1,10,0 !

Der Rest ist einfach: Summe pro Spalte, dann Skalarprodukt mit abnehmender Potenz von 60.

Ruby , 50 46 Bytes

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

Probieren Sie es online!

Ein grundlegender Port von Arnauld's Antwort wurde um GB für -4 Bytes verbessert.

C (gcc) , 65 64 63 Bytes

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

Probieren Sie es online!

Java 8, 64 60 Bytes

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

-4 Bytes dank @ceilingcat .

Probieren Sie es online aus. Erläuterung:

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 Bytes

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

Dieser liest die zu konvertierende Nummer aus STDIN.

Dies ist unbedingt die gleiche Lösung wie bei @Arnauld mit JavaScript.

F #, 128 Bytes

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

Probieren Sie es online!

Ungolfed würde es so aussehen:

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.mapFoldBackkombiniert Seq.mapund Seq.foldBack. Seq.mapFoldBackDurchläuft die Sequenz rückwärts und führt einen Akkumulatorwert durch die Sequenz (in diesem Fall i).

Für jedes Element in der Sequenz wird die babylonische Zahl berechnet (mit Seq.sumBy, die jedes Zeichen einer Zahl zuordnet und das Ergebnis summiert) und dann mit multipliziert i. iwird dann mit 60 multipliziert, und dieser Wert wird dann an das nächste Element in der Sequenz übergeben. Der Ausgangszustand für den Akku ist 1.

Die Reihenfolge der Aufrufe und Ergebnisse Seq.mapFoldBackfür die Eingabe <<<TT \ TTTTwäre beispielsweise:

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

Die Funktion liefert ein Tupel von seq<int>, int. Die fstFunktion gibt das erste Element in diesem Tupel und zurückSeq.sum führt die eigentliche Summierung durch.

Warum nicht benutzen Seq.mapioder ähnliches?

Seq.mapiordnet jedes Element in der Sequenz zu und stellt den Index für die Zuordnungsfunktion bereit. Von dort aus könnten Sie tun 60 ** index(wo **ist der Netzbetreiber in F #).

Aber **erfordert floats, nicht ints, was bedeutet , dass Sie entweder initialisieren müssen oder werfen alle Werte in der Funktion als float. Die gesamte Funktion wird ein zurückgeben float, was (meiner Meinung nach) ein wenig chaotisch ist.

Die Verwendung Seq.mapikann für 139 Bytes folgendermaßen erfolgen :

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 Bytes

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}

Probieren Sie es online!

In der umgekehrten Liste inkrementiere ich das Ergebnis in einer Schleife in Zählen <und T(mit der -allOption regexp) und inkrementiere eine natürliche Potenz von 60.

Richtige Version (siehe Kommentar)

APL (Dyalog Extended) , 18 Byte ^SBCS

Anonyme implizite Präfixfunktion.

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

Probieren Sie es 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 (Legacy) , 10 Byte

#Ç9%5BO60β

Probieren Sie es 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 Bytes

#Ç9%5B€O60β

Probieren Sie es online!

Der gleiche Algorithmus, aber in der modernen Version 05AB1E Ofunktioniert er nicht für Listen mit gemischten Ints und Listen, daher benötigen wir €Ostattdessen.