एक बेबीलोन की तरह गिनती

Question

चुनौती

इनपुट के रूप में एक बेबीलोनियन संख्या के ASCII प्रतिनिधित्व को देखते हुए, पश्चिमी अरबी अंकों में संख्या का उत्पादन करता है।

बेबीलोनियन न्यूमेरिकल सिस्टम

बेबीलोनियों की गिनती कैसे हुई? दिलचस्प है, उन्होंने बेस 10 सिस्टम के एक तत्व के साथ बेस 60 सिस्टम का उपयोग किया। आइए पहले सिस्टम के यूनिट कॉलम पर विचार करें:

बेबीलोनियों के केवल तीन प्रतीक थे: T(या, यदि आप इसे प्रस्तुत कर सकते हैं:) 𒐕जिसने 1 का प्रतिनिधित्व किया, और <(या, यदि आप इसे प्रस्तुत कर सकते हैं:) 𒌋जिसने 10 का प्रतिनिधित्व किया, और \(या, यदि आप इसे प्रस्तुत 𒑊करते हैं:) जो शून्य का प्रतिनिधित्व करता है।

नोट: तकनीकी रूप से, \(या 𒑊) शून्य नहीं है (क्योंकि बेबीलोन के लोगों में 'शून्य' की धारणा नहीं थी)। 'शून्य' का आविष्कार बाद में किया गया था, इसलिए \अस्पष्टता को रोकने के लिए एक प्लेसहोल्डर प्रतीक को बाद में जोड़ा गया था। हालांकि, इस चुनौती के प्रयोजनों के लिए, यह \शून्य के रूप में विचार करने के लिए पर्याप्त है

इसलिए, प्रत्येक स्तंभ में आप केवल प्रतीकों का मूल्य जोड़ते हैं, जैसे:

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

प्रत्येक कॉलम में कभी भी पांच <या नौ से अधिक नहीं होंगे T। \हमेशा कॉलम में अकेला दिखाई देगा।

अब, हमें अधिक कॉलम जोड़ने के लिए इसे विस्तारित करने की आवश्यकता है। यह किसी भी अन्य आधार साठ के समान ही काम करता है, जहां आप सबसे दाहिने स्तंभ का मूल्य गुणा करते हैं , एक को 60 1 से बाईं ओर , एक को 60 2 से छोड़ दिया जाता है । फिर आप संख्या का मान प्राप्त करने के लिए प्रत्येक के मूल्य को जोड़ते हैं।$60^0$$60^1$$60^2$

कॉलम अस्पष्टता को रोकने के लिए रिक्त स्थान से अलग हो जाएंगे।

कुछ उदाहरण:

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

नियम

• आप ASCII इनपुट ( T<\) या यूनिकोड इनपुट ( 𒐕𒌋𒑊) स्वीकार करने के लिए स्वतंत्र हैं
• इनपुट की गई संख्या हमेशा 10 7 से कम होगी$10^7$
• <रों हमेशा के लिए छोड़ दिया करने के लिए किया जाएगा Tप्रत्येक स्तंभ में रों
• \ हमेशा एक कॉलम में अकेला दिखाई देगा

जीतना

बाइट्स में सबसे छोटा कोड जीतता है।

Comments

@TaylorScott हां, आप कर सकते हैं

— बीटा डिके

मामले में यह मदद करता है: अधिकतम जिसे संभाला जाना आवश्यक है वह है 4 कॉलम:<<<<TTTTTT <TTTTTTT <<<<TTTTTT <<<<

— Wernisch

क्या स्तंभ हमेशा एक-एक स्थान से अलग होते हैं ? मैं इस पर भरोसा करने वाले उत्तर देखता हूं।

— केरान

हुक्का पाइप के साथ विदेशी प्रकार कहते हैं कि ओह ओह मट्ठा ओह, अय ओह मट्ठा ओह - एक बेबीलोन की तरह गिनें। महान। अब यह मेरे सिर में अटक गया है।

— cobaltduck

"How did the Babylonians count? Interestingly, they used a Base 60 system with an element of a Base 10 system."जो आज भी उपयोग में है; बेबीलोनियन संख्या प्रणाली ठीक वही है जो हम घड़ियों के लिए उपयोग करते हैं। दो दशमलव अंक प्रत्येक सेकंड, मिनट और घंटे, 60 सेकंड से मिनट, 60 मिनट से घंटा।

— रे

Answer 1

जावास्क्रिप्ट (ईएस 6), 44 बाइट्स

ASCII वर्णों की एक सरणी के रूप में इनपुट लेता है।

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

इसे ऑनलाइन आज़माएं!

कैसे?

बेबीलोनियन अंक प्रणाली को एक एकल रजिस्टर के साथ काम करने वाली 4-अनुदेश भाषा के रूप में देखा जा सकता है - चलो इसे संचायक कहते हैं।

के साथ शुरू , प्रत्येक वर्ण ग इनपुट सरणी में एक संशोधित संचायक कश्मीर इस प्रकार है:$k=0$$c$$a$$k$

• space: गुणा से 60 (: ऐड के रूप में लागू 59 कश्मीर के लिए कश्मीर )$k$$60$$59k$$k$
• <: से k जोड़ें$10$$k$
• T: वेतन वृद्धि $k$
• \: कुछ मत करो; यह NOPइस भाषा का निर्देश है (के रूप में लागू किया गया: से k जोड़ें )$0$$k$

Answer 2

सी (जीसीसी) , 140 138 136 बाइट्स

• छत के लिए धन्यवाद दो बाइट्स सहेजे गए ।

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

इसे ऑनलाइन आज़माएं!

Comments

+1 को अगले स्तर तक "एक बेबीलोनियन की तरह गिनना": D

— बीटा

Answer 3

पर्ल 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

Comments

आपने मुझे कुछ मिनटों के लिए हराया। यहाँ मैं क्या कर रहा हूँ: {:60[.words>>.&{sum (.ords X%151)X%27}]}(40 बाइट्स)

— nwellnhof

@nwellnhof बहुत अच्छा किया! आपको मॉड वैल्यू कैसे मिली?

— जो किंग

बस क्रूर बल से।

— nwellnhof

Answer 4

जेली ,  13  12 बाइट्स

ḲO%7C%13§ḅ60

वर्णों की एक सूची को स्वीकार करने वाला एक विचित्र लिंक जो पूर्णांक देता है।

इसे ऑनलाइन आज़माएं!

कैसे?

Ḳ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द्वारा Ordinal मान रही 53, 5है, और 1के लिए <, T, \क्रमशः तो प्रदर्शन विभाजन पूर्णांक, :द्वारा 5प्राप्त करने के लिए 10, 1और 0)

Comments

लोल, मैंने इस वजह से अपना उत्तर बिल्कुल हटा दिया है , क्योंकि मुझे याद है कि मैं आधार रूपांतरण का उपयोग कर सकता हूं लेकिन शाब्दिक रूप से यह पता लगाने के लिए बहुत आलसी था कि कैसे। +1

— श्री एक्सकोडर

Answer 5

05AB1E , 13 बाइट्स

8740|Ç%4/O60β

इसे ऑनलाइन आज़माएं!

मैं अपने जेली उत्तर के साथ कितना आलसी था, इसके लिए बनाने के लिए , यहां 05AB1E xD में प्रस्तुत किया गया है।

Comments

05AB1E-ers की सहायता करें, 8740क्या संख्याओं को संपीड़ित करने का कोई तरीका नहीं था ?

— मिस्टर एक्सकोडर

codegolf.stackexchange.com/a/166851/52210 दुर्भाग्य से यह कम नहीं होगा: •Yη•(4 बाइट्स)

— केविन क्रूज़सेन

@KevinCruijssen धन्यवाद! यह उत्तर बहुत उपयोगी है, मैं इसे भविष्य में पूरी तरह से उपयोग

— करूंगा

खुशी है कि टिप उपयोग की है। :) मैंने इन बातों का उपयोग करके कुछ उत्तरों को देखने के बाद पता लगाया। शब्दकोश भाग यहाँ समझाया गया था । और अन्य स्ट्रिंग्स या बड़े पूर्णांकों का संपीड़न मैंने "हंस" और 246060 के लिए जुड़े हुए उदाहरण उत्तरों को देखने के बाद खुद को समझ लिया ।

— केविन क्रूज़सेन

1|Ç7%-13%O60β13 भी है - क्या यह गोल्फ है?

— जोनाथन एलन

Answer 6

पायथन 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 बाइट, मिस्टर एक्सकोडर की बदौलत
• -4 बाइट्स, पून लेवी को धन्यवाद
• -2 बाइट्स, मैथ्यू जेन्सेन को धन्यवाद

Comments

95:(ord(c)%5/2or 11)-1

— श्री Xcoder

@ Mr.Xcoder धन्यवाद :)

— TFeld

87:8740%ord(c)/4

— पून लेवी

-2 को दूसरे योग के चारों ओर कोष्ठकों को हटाकर ( इसे ऑनलाइन आज़माएं!

— मैथ्यू जेन्सेन

— @MatthewJensen

Answer 7

एक्सेल VBA, 121 बाइट्स

32-बिट कार्यालय में प्रतिबंधित 64-बिट संस्करणों में प्रकार शाब्दिक के रूप में ^कार्य करता हैLongLong

सेल से इनपुट लेता है 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

Answer 8

दिल्लोग एपीएल , 33 30 बाइट्स

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

इसे ऑनलाइन आज़माएं!

संपादित करें: -3 बाइट्स ngn के लिए धन्यवाद

'\ T<'⍳वर्णों को संख्याओं के साथ प्रतिस्थापित करता है (स्ट्रिंग स्थिरांक में उनकी स्थिति), और ⌽इनपुट को उलटता है इसलिए सबसे महत्वपूर्ण 'अंक' अंतिम हैं। इससे अंतरिक्ष की संख्या (स्ट्रिंग स्थिरांक में 2 सूचकांक) की संख्या की गणना +\2=करके 60 (वांछित द्वारा लागू 60*) की वांछित शक्ति की एक रनिंग काउंट रखने की अनुमति मिलती है ।

⌊10*⍵-3प्रत्येक चरित्र के लिए दस की वांछित शक्ति देता है। स्ट्रिंग स्थिरांक में वर्णों का क्रम और -3 ऑफसेट '\' का कारण बनता है और ऋणात्मक संख्याओं में जाने के लिए स्थान बनाता है, जिसके परिणामस्वरूप उन वर्णों को 10 की शक्ति तक बढ़ा दिया जाता है, जिससे उन्हें समाप्त कर दिया जाता है ⌊।

अब हमें बस इतना करना है कि शक्तियों के -10 अंकों को शक्ति के 60 स्थान के मान से गुणा करें और बहुत से योग करें +/।

Comments

के साथ अलग तुलना से बचने के द्वारा कुछ बाइट्स को ' '{+/(⌊10*⍵-3)×60*+\2=⍵}'\ T<'⍳⌽

— बचाएं

Answer 9

पायथन 2 , 62 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह अर्नूल के उत्तर से तकनीक का उपयोग करता है ।

Answer 10

कैनवस , 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

Answer 11

APL (NARS ←io ← 0), 28 वर्ण, 56 बाइट्स

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

प्रकार की जाँच के साथ कुछ परीक्षण:

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

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

प्रत्येक प्रकार का परिणाम संख्या है।

Answer 12

जावास्क्रिप्ट (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)

इसे ऑनलाइन आज़माएं!

मैं "कार्यात्मक-शैली" सरणी के संचालन से थोड़ा रोमांचित हूं, एएससीआईआई इनपुट का उपयोग करता है, जहां तक ​​मैं बता सकता हूं, जेएस को गोल्फ के लिए बहुत अच्छा नहीं है

मैं इसे पोस्टीरिटी की खातिर रख रहा हूं, लेकिन यह एक भोली / गूंगा समाधान है, मैं आपको सुझाव देता हूं कि आप अरनुल्द के जवाब की जांच करें जो चुनौती का कार्यान्वयन अधिक दिलचस्प है

Comments

@ शैगी ऐसा लगता है कि यह मेरे लिए काम करता है!

— स्काइडदेव

c<'T'के स्थान पर काम करता हैc=='<'

— श्री Xcoder

के &&साथ बदलकर 1 और बचाएं |।

— झबरा

@ बंद करो और for...ofछोरों का उपयोग करके बहुत अधिक बचाओ : P

— ASCII-only

Answer 13

रेटिना , 29 26 23 बाइट्स

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

इसे ऑनलाइन आज़माएं! नईलाइन पृथक्करण का उपयोग करता है, लेकिन लिंक में सुविधा के बजाय रिक्त स्थान का उपयोग करने के लिए हेडर शामिल हैं। संपादित करें: @ केविनक्रूजसेन की मदद से 3 बाइट्स बचाए। @FryAmTheEggman की बदौलत एक और 3 बाइट्स बचाए। स्पष्टीकरण:

<
10*T

प्रत्येक <को 10 Tएस से बदलें ।

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

पहली पंक्ति लें, इसे 60 से गुणा करें, और अगली पंक्ति जोड़ें। तब तक दोहराएं जब तक कि केवल एक पंक्ति शेष न हो।

T

एस की गणना करें T।

तेजी से 51-बाइट संस्करण:

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

इसे ऑनलाइन आज़माएं! नईलाइन पृथक्करण का उपयोग करता है, लेकिन लिंक में सुविधा के बजाय रिक्त स्थान का उपयोग करने के लिए हेडर शामिल हैं। स्पष्टीकरण:

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

प्रत्येक पंक्ति को व्यक्तिगत रूप से मिलाएं, और Ts की संख्या और 10 गुना s की संख्या <गिनें। यह प्रत्येक रेखा को उसके आधार -60 "अंक" मान में परिवर्तित करता है।

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

बेस 60 रूपांतरण, एक समय में एक लाइन चल रहा है। गणना गति के लिए दशमलव में की जाती है।

Comments

मुझे पूरा यकीन है कि तीसरी लाइन सिर्फ <बिना ही हो सकती है +, जब तक कि मैं किसी तरह के किनारे के मामले को नहीं देख रहा हूं।

— केविन क्रूज़सेन

@ केविनक्रूजसेन इससे भी बेहतर, जैसा $&कि अब हमेशा एक चरित्र होता है, मैं डिफ़ॉल्ट चरित्र का उपयोग कर सकता हूं, एक और दो बाइट्स बचा सकता हूं!

— नील

बहुत सुंदर! :) पता नहीं था कि एकल पात्रों के लिए निहित किया जा सकता है।

— केविन क्रूज़सेन

@ केविनक्रूजसेन खैर, मुझे परवाह नहीं है कि चरित्र क्या है, क्योंकि मैं केवल लंबाई ले रहा हूं; रेटिना 1 में आपको रेटिना के पुराने संस्करणों में कुछ _समय मिलता $*है 1।

— नील

ओह समझा। आपका आरंभिक कोड सभी <को एक ही मैच के रूप में ले रहा था और उन्हें लंबाई ( <मैच की मात्रा ) से <10 गुना दोहरा रहा था, और मेरा प्रस्तावित बदलाव हर 10 बार अलग-अलग दोहरा रहा है (जो आपने 2 बाइट्स के साथ किया है, जिसका उपयोग 1 निहित है) 10*)। अब मैं बेहतर ढंग से समझता हूं कि +शुरू में ऐसा क्यों था। मुझे रेटिना निर्मितियों के बारे में बहुत अधिक जानकारी नहीं है, केवल सामान्य रूप से रेगीक्स हैं, इसलिए मेरा प्रस्तावित परिवर्तन है क्योंकि मैं पहले से ही इसे हर >10 बार दोहराता हूं । ;)

— केविन क्रूज़सेन

Answer 14

बैश (सेड और डीसी के साथ), 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(प्रिंट)।

Answer 15

जे , 34 30 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 16

Dyalog एपीएल, 35 32 बाइट्स

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

इसे ऑनलाइन आज़माएं!

31 dzaima / APL में

Answer 17

नोथर , 55 बाइट्स

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

इसे ऑनलाइन आज़माएं!

@Arnauld के रूप में एक ही दृष्टिकोण।

Answer 18

चारकोल , 26 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

≔⁰θ

परिणाम साफ़ करें।

ＦＳ«...»

इनपुट वर्णों पर लूप करें। ≡आदेश में यह एक "डिफ़ॉल्ट" ब्लॉक की खोज से रोकने के लिए एक ब्लॉक में लपेटा जाता है।

≡ι

वर्तमान चरित्र पर स्विच करें ...

 ≦×⁶⁰θ

यदि यह एक स्थान है तो परिणाम को 60 से गुणा करें ...

<≦⁺χθ

अगर यह एक <परिणाम में 10 जोड़ रहा है ...

T≦⊕θ

यदि यह Tपरिणाम में वृद्धि है।

Ｉθ

परिणाम प्रिंट करें।

Answer 19

आर , 98 81 बाइट्स

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

इसे ऑनलाइन आज़माएं!

स्ट्रिंग पार्सिंग के कारण लंबे समय तक। 16 अनावश्यक बाइट्स को शेविंग करने के लिए धन्यवाद Giusppe।

yयूनिकोड इनपुट के बाइटकोड मान को परिभाषित करें औरR = y("T<\") = y("𒐕𒌋𒑊")

निरीक्षण करें कि R%%3 = 1,2,0और R%%6 = 1,5,0... तो R%%3 * R%%6 = 1,10,0!

बाकी आसान है: प्रति कॉलम योग, फिर 60 की घटती शक्तियों के साथ डॉट-उत्पाद।

Comments

पोर्ट कम करने का उपयोग करते हुए अर्नाउल्ड के asnwer अधिक गोल्फ होने की संभावना है।

— JayCe

scan(,"")स्वचालित रूप से रिक्त स्थान पर विभाजित नहीं होता है?

— Giuseppe

हालांकि mods के साथ अच्छी चाल! मैं यह पता लगाने की कोशिश कर रहा था, लेकिन यह नहीं मिल सका ... और इसे एक और बाइट के लिए एक्सप्रेशन एक्सप्रेशन में /60बदल दिया जा सकता -1है, साथ ही इसे सभी कोष्ठकों में <-बदल दिया जा सकता =है।

— Giuseppe

@Giuseppe मैंने %% 3 की कोशिश की और यह आशाजनक था इसलिए मैं देखता रहा ... एक डॉट उत्पाद का उपयोग करके मुझे केवल एक अतिरिक्त बाइट बचाई :)

— JayCe

Answer 20

रूबी , 50 46 बाइट्स

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

इसे ऑनलाइन आज़माएं!

4 बाइट्स के लिए GB द्वारा Arnauld के उत्तर का एक मूल पोर्ट सुधारा गया।

Comments

45 बाइट्स- वास्तव में 47 यदि आप "मैप" के बजाय "बाइट्स" का उपयोग करते हैं

— जीबी

धन्यवाद @ जीबी, मैं शायद लंबे संस्करण के साथ रहूंगा, क्योंकि कच्चे बायोटेक के रूप में इनपुट लेना एक भाषा के लिए थोड़ा बहुत उदार लगता है जो आमतौर पर तार का समर्थन करता है।

— किरिल एल।

एक और बाइट: 46 बाइट्स

— जीबी

Answer 21

सी (जीसीसी) , 65 64 63 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Comments

के return oसाथ बदलने s=oसे एक और 5 बाइट्स बचाता है।

— एरिक

Answer 22

जावा 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

Answer 23

पर्ल-एफ // -ई, 39 बाइट्स

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

यह एसटीडीआईएन से परिवर्तित संख्या को पढ़ता है।

यह उसी समाधान के लिए आवश्यक है जैसा कि @Arnauld द्वारा जावास्क्रिप्ट का उपयोग करके दिया गया है।

Answer 24

एफ #, 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.foldBack। Seq.mapFoldBackअनुक्रम के माध्यम से पीछे की ओर पुनरावृत्त होता है, और अनुक्रम के माध्यम से एक संचायक मान को थ्रेड करता है (इस मामले में, i)।

अनुक्रम में प्रत्येक तत्व के लिए, बेबीलोन संख्या की गणना की जाती है (द्वारा 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समारोह है कि टपल में पहला आइटम देता है, और Seq.sumवास्तविक जोड़ने पर है।

उपयोग Seq.mapiया समान क्यों नहीं ?

Seq.mapiअनुक्रम में प्रत्येक तत्व को मैप करता है, और मैपिंग फ़ंक्शन को सूचकांक प्रदान करता है। वहां से आप कर सकते हैं 60 ** index(जहां **एफ # में पावर ऑपरेटर है)।

लेकिन **आवश्यकता है 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

Answer 25

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( -allregexp विकल्प के साथ ) बढ़ाता हूं और एक प्राकृतिक को 60 की शक्ति के रूप में बढ़ाता हूं ।

सही संस्करण (टिप्पणी देखें)

Comments

ऐसा लगता है कि मैं इस एक को विफल कर दिया था, क्योंकि अंतिम संख्या में \ ... मुझे regsub {\\} $l0 lपहले फॉरेस्ट लूप चाहिए था ...

— david

Answer 26

एपीएल (Dyalog विस्तारित) , 18 बाइट्स ^SBCS

बेनामी tacit उपसर्ग समारोह।

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

Answer 27

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मिश्रित ints और सूचियों की सूची पर काम नहीं करता है, इसलिए हमें €Oइसके बजाय की आवश्यकता है ।