Meydan okuma

ASCII'nin Babil sayısının girdi olarak gösterilişi göz önüne alındığında, sayıyı Batı Arapça rakamlarıyla çıkar.

Babil Sayısal Sistem

Babilliler nasıl sayıldı? İlginç bir şekilde, bir Base 10 sistemi elemanına sahip bir Base 60 sistemi kullandılar. İlk önce sistemin birim sütununu düşünelim:

Babillilerin sadece üç sembolü vardı: T(veya yapabilirseniz:) 𒐕1'i temsil ediyordu ve <(veya bunu yapabilirseniz:) 𒌋10'u temsil ediyordu ve \(veya, bunu yaparsanız:) 𒑊sıfırı temsil ediyordu.

Not: Teknik olarak, \(veya 𒑊) sıfır değildir (çünkü Babillilerde 'sıfır' kavramı yoktur). 'Sıfır' daha sonra icat edildi, \belirsizliği önlemek için daha sonra eklenen bir yer tutucu sembolü de vardı. Ancak, bu zorluğun amaçları için, \sıfır olarak kabul etmek yeterlidir

Böylece, her bir sütunda sadece sembollerin değerini toplarsınız, örneğin:

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

Her sütunda asla beşten <fazla veya dokuzdan fazla olamaz T. \sütunda her zaman yalnız görünecektir.

Şimdi, bunu daha fazla sütun eklemek için genişletmemiz gerekiyor. Bu, diğer altmış altmışlarla tam olarak aynı şekilde çalışır; burada en sağdaki sütunun değerini , sola doğru , sola doğru ile çarpın . Daha sonra sayının değerini almak için her birinin değerini toplarsınız.60 1 60 $60^0$$60^1$$60^2$

Belirsizliği önlemek için sütunlar boşluklarla ayrılacaktır.

Bazı örnekler:

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

kurallar

• ASCII girişini ( T<\) veya Unicode girişini ( 𒐕𒌋𒑊) kabul etmekte özgürsünüz
• Girilen numara daima altında olacaktır.$10^7$
• <Hep sol olacak Ther sütunda s
• \ bir sütunda her zaman tek başına görünecek

Kazanan

Bayt cinsinden en kısa kod kazanır.

JavaScript (ES6), 44 bayt

Girdiyi bir ASCII karakter dizisi olarak alır.

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

Çevrimiçi deneyin!

Nasıl?

Babil Rakam Sistemi, tek bir kütükle çalışan 4 komutlu bir dil olarak görülebilir - hadi akümülatör diyelim.

ile başlayarak, giriş dizisindeki her karakteri akümülatörü aşağıdaki gibi değiştirir :c a $k=0$$c$$a$$k$

• space: Çarpma tarafından (: eklenti olarak uygulanan için )60 59 k $k$$60$$59k$$k$
• <: Ekleme için$10$$k$
• T: artış$k$
• \: hiçbir şey yapma; bu NOPbu dilin talimatı (: eklenti olarak uygulanan ile )$0$$k$

C (gcc) , 140 138 136 bayt

• Ceilingcat sayesinde iki byte kurtarıldı .

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

Çevrimiçi deneyin!

Perl 6 , 39 bayt

Nwellnhof sayesinde -3 bayt

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

Çevrimiçi deneyin!

Çivi yazısı karakterlerini kullanır.

Açıklama:

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

Jöle ,  13  12 bayt

ḲO%7C%13§ḅ60

Bir tamsayı üreten bir karakter listesini kabul eden bir monadik bağlantı.

Çevrimiçi deneyin!

Nasıl?

Ḳ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

Başka bir 12: ḲO⁽¡€%:5§ḅ60( ⁽¡€olup 1013, bu MODULOS böylece 1013ile Ordinal değerleri elde 53, 5ve 1için <, T, \sırasıyla daha sonra gerçekleştirir bölümü tamsayıdır :ile 5elde etmek için 10, 1ve 0)

05AB1E , 13 bayt

8740|Ç%4/O60β

Çevrimiçi deneyin!

Jelly cevabımla ne kadar tembel olduğumu telafi etmek için , işte 05AB1E xD.

Python 2 , 96 93 87 85 bayt

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

Çevrimiçi deneyin!

Kaydedilen:

• -1 bayt, Bay Xcoder sayesinde
• -4 bayt, Poon Levi sayesinde
• -2 byte, Matthew Jensen sayesinde

Excel VBA, 121 bayt

64 Bit sürümlerinde hazır bilgi türü olarak ^görev yapan 32 Bit Office ile LongLongsınırlıdır

Hücreden girdi alır A1ve hemen açılan pencereye çıkar.

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 ve Yorumlandı

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 bayt

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

Çevrimiçi deneyin!

Düzenleme: ngn sayesinde -3 bayt

'\ T<'⍳karakterleri sayılarla değiştirir (dizgede sabit olan konumları) ve ⌽girdiyi tersine çevirir, böylece en önemli 'basamaklar' en son kalır. Bu, bir boşluğun (dizgideki sabit dizinde 2) kaç kez +\2=sayılacağını (istenen 60*dizgede 2) sayarak 60'ın istenen gücünde çalışan sayımını sürdürmesini sağlar .

⌊10*⍵-3Her karakter için istenen gücü on verir. Dize sabiti ve -3 kayması içindeki karakterlerin sırası '\' ve boşlukların negatif sayılara gitmesine neden olur ve bu karakterler 10'un gücüne yükseltildiğinde kesirler elde edilir ve bunların ortadan kaldırılmasını sağlar ⌊.

Şimdi tek yapmamız gereken, 10 basamaklı güçlerin 60 basamaklı güçlerinin değerleriyle çarpması ve lotu toplamasıdır +/.

Python 2 , 62 bayt

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

Çevrimiçi deneyin!

Bu, Arnauld'un cevabındaki tekniği kullanır .

Tuval , 20 17 16 bayt

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

Burada dene!

Açıklama:

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 bayt

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

tip kontrolü ile bazı testler:

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

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

Her tip sonuç sayıdır.

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

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

Çevrimiçi deneyin!

"İşlevsel stil" dizi işlemleri konusunda biraz takıntılıyım, ASCII girişini kullanıyor, söyleyebileceğim kadarıyla JS çok iyi değil.

Ben posterity aşkına bu tutuyorum, ama bu naif / dilsiz bir çözümdür, ben kontrol önermek Arnauld yanıtını çok daha meydan okuma bir uygulama ilginç olan

Retina , 29 26 23 bayt

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

Çevrimiçi deneyin! Yeni satır ayrımı kullanır, ancak bağlantı kolaylık sağlamak için boşluk kullanmak için başlık içerir. Düzenleme: @KevinCruijssen yardımı ile 3 bayt kaydedildi. @ FryAmTheEggman sayesinde 3 bayt daha kaydedildi. Açıklama:

<
10*T

Her birini <10 Tsn ile değiştirin .

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

İlk satırı alın, 60 ile çarpın ve sonraki satırı ekleyin. Sonra sadece bir satır kalana kadar tekrarlayın.

T

S say T.

Daha hızlı 51 bayt sürüm:

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

Çevrimiçi deneyin! Yeni satır ayrımı kullanır, ancak bağlantı kolaylık sağlamak için boşluk kullanmak için başlık içerir. Açıklama:

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

Her çizgiyi ayrı ayrı eşleştirin ve Ts sayısını ve s sayısının 10 katını sayın <. Bu, her satırı 60 "basamağı" değerine dönüştürür.

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

Her seferinde bir satır çalıştıran Base 60 dönüşümü. Hesaplama hız için ondalık olarak yapılır.

Bash (sed ve dc ile), 50 bayt

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

Alanından ayrılmış girdiyi alır stdin, çıktılarınıstdout

Çevrimiçi deneyin!

açıklama

Girdiyi dönüştürmek için sed komutunu kullanır; örneğin, girdi <<<TT \ TTTTdönüştürülünceye kadar, düzenli ifade eşleşmeleriyle eşleşir A+A+A+1+1+60*60*1+1+1+1+. Daha sonra bu girdi açık giriş yürütme komutuyla dc'ye beslenir ?, önce z(yığın uzunluğunu (0) yığına iter, böylece ilaveyi topraklayacağımız bir yere sahip oluruz) ve ardından p(yazdırır).

J , 3430 bayt

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

Çevrimiçi deneyin!

Dyalog APL, 35 32 bayt

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

Çevrimiçi deneyin!

31 içinde dzaima / APL

Noether , 55 bayt

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

Çevrimiçi deneyin!

@Arnauld ile aynı yaklaşım.

Kömür , 26 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Açıklama:

≔⁰θ

Sonucu temizleyin.

ＦＳ«...»

Giriş karakterleri üzerinde döngü yapın. ≡Komutu bir "varsayılan" blok bulma önlemek için bir blokta sarılır.

≡ι

Geçerli karakteri değiştir ...

 ≦×⁶⁰θ

boşluksa sonucu 60 ile çarpın ...

<≦⁺χθ

eğer öyleyse <sonuca 10 ekleyin ...

T≦⊕θ

eğer o Tzaman sonucu arttırır.

Ｉθ

Sonucu yazdırın.

R , 98 81 bayt

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

Çevrimiçi deneyin!

String ayrıştırma nedeniyle gülünç uzun. 16 gereksiz baytı tıraş için teşekkürler Giusppe.

Tanımlama yUnicode girişinin bayt kodu değeri veR = y("T<\") = y("𒐕𒌋𒑊")

Bunu gözlemle R%%3 = 1,2,0ve R%%6 = 1,5,0... öylesine R%%3 * R%%6 = 1,10,0!

Gerisi kolaydır: sütun başına toplam, sonra 60'lık azalan güçlere sahip nokta ürün.

Ruby , 50 46 bayt

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

Çevrimiçi deneyin!

Arnauld'un cevabının temel limanı, GB tarafından -4 bayt için iyileştirildi.

C (gcc) , 65 64 63 bayt

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

Çevrimiçi deneyin!

Java 8, 64 60 bayt

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

@Ceilingcat sayesinde -4 bayt .

Çevrimiçi deneyin. Açıklama:

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 bayt

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

Bu dönüştürülecek sayıyı STDIN'den okur.

Bu, JavaScript kullanarak @Arnauld tarafından verilenle aynı özümdür.

F #, 128 bayt

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

Çevrimiçi deneyin!

Ungolfed şöyle görünürdü:

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.mapFoldBackSeq.mapve birleştirir Seq.foldBack. Seq.mapFoldBackdizi boyunca geriye doğru yinelenir ve dizi boyunca bir akümülatör değeri geçirir (bu durumda i).

Dizideki her öğe için, Babilce sayı hesaplanır ( Seq.sumByher karakteri bir sayı ile eşleştirir ve sonucu toplar) ve ardından çarpılır i. idaha sonra 60 ile çarpılır ve bu değer daha sonra dizideki bir sonraki öğeye geçirilir. Akümülatör için başlangıç ​​durumu 1'dir.

Örneğin, aramalar ve Seq.mapFoldBackgiriş için sonuçların sırası <<<TT \ TTTTşöyle olacaktır:

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

İşlev bir demet döndürür seq<int>, int. fstFonksiyon bu demet içinde ilk öğeyi döndürür ve Seq.sumfiili toplanmasıyla yapar.

Neden kullanmıyor Seq.mapiveya benzer?

Seq.mapiher öğeyi dizideki eşler ve eşleme işlevine dizini sağlar. Oradan yapabilecekleriniz 60 ** index( **F # 'daki güç operatörü nerede ).

Ancak **gerektirir floats, değil ints, bu, işlevdeki tüm değerleri başlatmanız veya almanız gerektiği anlamına gelir float. Tüm işlev, float(bence) biraz dağınık olan bir döndürür .

Kullanma Seq.mapionun için böyle yapılabilir 139 bayt :

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 bayt

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}

Çevrimiçi deneyin!

Tersine çevrilmiş listede, sonucu sayma <ve T( -allregexp seçeneğiyle) artırma ve 60'lık bir doğal gücü artırma döngüsüne giriyorum.

Doğru sürüm (yoruma bakınız)

APL (Dyalog Genişletilmiş) , 18 bayt ^SBCS

Anonim zımni önek işlevi.

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

Çevrimiçi deneyin!

                  ⊢  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 (eski) , 10 bayt

#Ç9%5BO60β

Çevrimiçi deneyin!

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

#Ç9%5B€O60β

Çevrimiçi deneyin!

Aynı algoritma, ancak modern 05AB1E'de Okarışık girişlerin ve listelerin listeleri üzerinde çalışmadığı için €Obunun yerine ihtiyacımız var .