23

कई साल पहले, हॉट व्हील्स ने एक सरल फ़्लैश खेल बनाया, जिसे "फॉर्मूला फ्यूलर्स रेसर्स" * कहा जाता है । गेम खेलने के लिए, आप अपनी कार में डालने के लिए एक फ्रिज से तीन अवयवों का चयन करते हैं, जिसे बाद में कंप्यूटर की बेतरतीब ढंग से बनाई गई कार के खिलाफ चलाया जाता है। यह इस खेल के यांत्रिकी बहुत सरल हैं पता चला है। सबसे पहले, आपकी कार की वास्तविक दौड़ "समय" बेतरतीब ढंग से उत्पन्न होती है और इस पर कोई असर नहीं पड़ता है कि आप दौड़ जीतते हैं या नहीं। दूसरे, दौड़ के विजेता को एक स्कोर द्वारा निर्धारित किया जाता है जिसकी गणना चयनित अवयवों से की जाती है (डुप्लिकेट सामग्री की अनुमति है, और आदेश मायने रखता है)। प्रत्येक घटक में एक संबंधित "मूल्य" और एक संबंधित "ऑपरेशन" है जैसा कि निम्नलिखित तालिका में दिखाया गया है:

#   ingredient     val  op
1   Hot Salsa       2   +
2   Root Beer       1   +
3   Milk            1   +
4   Pickle Juice    2   +
5   Mystery Lunch   -3  *
6   BBQ Sauce       2   +
7   Egg             1   +
8   Ketchup         2   +
9   Mustard         -1  *
10  Melon           1   +
11  Chocolate Milk  1   +
12  Mayonnaise      -2  *
13  Baby Food       0   +
14  Pepper          1   +
15  Salt            2   +
16  Syrup           -1  *
17  Salad Dressing  2   +
18  Orange Juice    1   +
19  Soy Sauce       2   +

सुविधा के लिए, यह चुनौती उनकी संख्या से अवयवों का जिक्र करेगी न कि उनके नाम से। एक अंक की गणना करने के लिए यहां चरण दिए गए हैं:

सबसे पहले, पहले घटक के मूल्य के साथ स्कोर को इनिशियलाइज़ करें।
फिर, वर्तमान स्कोर को संयोजित करने के लिए दूसरे घटक के संचालन का उपयोग करें और एक अद्यतन स्कोर प्राप्त करने के लिए दूसरे घटक के मूल्य को।
अंत में, वर्तमान स्कोर को संयोजित करने के लिए तीसरे घटक के संचालन का उपयोग करें और अंतिम स्कोर प्राप्त करने के लिए तीसरे घटक का मान।

उच्च स्कोर बेहतर हैं और हमेशा कम स्कोर को हराते हैं।

उदाहरण के लिए, सामग्री 1 2 3का स्कोर है (2+1)+1 = 4। सामग्री 7 5 6का स्कोर है (1*-3)+2 = -1। इसलिए, 1 2 3धड़कता है 7 5 6।

चुनौती

इस चुनौती में, आप एक प्रोग्राम लिखेंगे जो 3 पूर्णांकों की क्रमबद्ध सूची लेता है और इसी स्कोर को आउटपुट करता है।

इनपुट

आपका कार्यक्रम सबसे सुविधाजनक प्रारूप में तीन पूर्णांकों की सूची को स्वीकार कर सकता है। आपको घटक नामों के लिए 1-अनुक्रमणिका (जैसा कि ऊपर) या 0-अनुक्रमण (ऊपर प्रत्येक सूचकांक से 1 घटाएँ) का उपयोग करने की अनुमति है।

ouput

आपके कार्यक्रम में स्कोर का संकेत देने वाला एक पूर्णांक होना चाहिए।

परीक्षण के मामलों

4 5 5  =>  18 // max score
5 5 5  =>  -27 // min score
13 13 13  =>  0
1 2 3  =>  4
7 5 6  =>  -1
16 2 19  =>  2
19 7 12  =>  -6

* यह पृष्ठ बहुत पुराना है और कुछ ब्राउज़रों में काम नहीं करता है, लेकिन आपको इस चुनौती के लिए खेल खेलने की आवश्यकता नहीं है।

code-golf kolmogorov-complexity arithmetic

— PhiNotPi
स्रोत

1

तो मूल रूप से सालसा + दोपहर का भोजन + मेयो = अजेय?

— मैथ्यू रोह

3

@SIGSEGV डुप्लिकेट सामग्री की अनुमति है। सालसा, लंच, लंच 18 के स्कोर के लिए अनुमति दी जाती है जो आपके 12.

— लेवल रिवर सेंट

2

संदर्भ के लिए, यहाँ खेल का एक संग्रह है।

— मैथ्यू रोह

4

फ्रिज में नमक कौन रखता है? :)

— वॉसनाम

3

1. मुझे नहीं पता कि नमक फ्रिज में क्यों होगा। 2. हाँ, एक बार जब आप एक 18-बिंदु कॉम्बो की खोज करते हैं तो आप सचमुच अजेय हो जाते हैं और खेल अर्थहीन हो जाता है।

— फीनोटपी

13

जेली , 24 बाइट्स

“zẈ€$ụ¤’b6’ị@µỊị⁾+×żCFḊV

0-अनुक्रमित अवयवों की सूची लेता है।

इसे ऑनलाइन आज़माएं! या एक परीक्षण सूट देखें

कैसे?

मानों को आधार -6 संख्या के रूप में संपीड़ित करने के थोड़ा जटिल रूप का उपयोग करता है और तथ्य यह है कि गुणक प्रविष्टियां नकारात्मक हैं। बेस -6 अंकों को प्राप्त करने के लिए बस 3 से ऊपर जाने के बजाय, संवर्धित मानों का उपयोग किया जाता है - यह बाइट्स को बचाता है जिससे Ịकि पूरक कदम से पहले नकारात्मक प्रविष्टियों को बाहर निकालने की अनुमति मिलती है, जबकि बेस-250 में एक बाइट की बचत भी होती है। संपीड़न।

“zẈ€$ụ¤’b6’ị@µỊị⁾+×żCFḊV - Main link: 0-based ingredient list  e.g. [6,4,5]
“zẈ€$ụ¤’                 - base 250 compressed number: 120851767994004
        b6               - convert to base 6: [1,1,0,5,0,1,0,3,1,1,4,2,1,0,3,0,1,0,0]
          ’              - decrement: [0,0,-1,4,-1,0,-1,2,0,0,3,1,0,-1,2,-1,0,-1,-1]
           ị@            - index into [reversed @rguments]          [0,4,-1]
             µ           - monadic chain separation (call that x)
              Ị          - insignificant(x)? (abs(x)<=1)            [1,0,1]
                ⁾+×      - ['+','×']
               ị         - index into                               ['+','×','+']
                    C    - complement(x) (1-x)                      [1,-3,2]
                   ż     - zip                                      [['+',1],['×',-3],['+',2]]
                     F   - flatten                                  ['+',1,'×',-3,'+',2]
                      Ḋ  - dequeue                                  [1,'×',-3,'+',2]
                       V - evaluate as Jelly code                   -1

— जोनाथन एलन
स्रोत

"आधार 250 संपीड़ित संख्या" भाग कैसे काम करता है?

— ckjbgames

@ckjbgames zẈ€$ụ¤को जेली कोड-पृष्ठ में उनके (1-अनुक्रमित) अनुक्रमित के रूप में पढ़ा जाता है, जो कि हैं [123,188,13,37,226,4], और आधार-250 नंबर के रूप में व्याख्या की गई है: 123*250**5+188*250**4+13*250**3+37*250**2+226*250**1+4*250**0=120851767994004( ट्यूटोरियल के स्ट्रिंग-शाब्दिक अनुभाग देखें ।)

— जोनाथन एलन

ओह, एक स्ट्रिंग शाब्दिक।

— cjjbgames

यह मेरा दृष्टिकोण था जब तक मुझे एहसास हुआ कि "-3" का मतलब "-3" नहीं है जब 05AB1E कोड के रूप में मूल्यांकन किया जाता है।

— मैजिक ऑक्टोपस Urn

11

जावास्क्रिप्ट (ईएस 6), 89 84 82 78 73 बाइट्स

0-इंडेक्सिंग का उपयोग करके, 3 पूर्णांक की एक सरणी के रूप में इनपुट लेता है।

a=>(o=a=>F()<0?a*n:a+n)(o((F=_=>n='5445054524413452545'[a.shift()]-3)()))

परीक्षण के मामलों

कोड स्निपेट दिखाएं

let f =

a=>(o=a=>F()<0?a*n:a+n)(o((F=_=>n='5445054524413452545'[a.shift()]-3)()))

console.log(f([3, 4, 4]))     // =>  18
console.log(f([4, 4, 4]))     // =>  -27
console.log(f([12, 12, 12]))  // =>  0
console.log(f([0, 1, 2]))     // =>  4
console.log(f([6, 4, 5]))     // =>  -1
console.log(f([15, 1, 18]))   // =>  2
console.log(f([18, 6, 11]))   // =>  -6

स्निपेट का विस्तार करें

पिछला संस्करण, 78 बाइट्स

(a)(b)(c)0-इंडेक्सिंग का उपयोग करके, 3 सिंटर्स को करी सिंटैक्स में ले जाता है ।

a=>b=>(o=a=>b=>(n=F(b))<0?a*n:a+n)(o((F=n=>'5445054524413452545'[n]-3)(a))(b))

यह काम किस प्रकार करता है

इस कोड के बारे में एक छोटी सी असामान्य बात यह है कि यह केवल cur कॉमन ’करी वाक्यविन्यास में 2 तर्क लेता है a => b =>और अंत में एक फ़ंक्शन लेता है जो 3rd को लेता है।

टूट - फूट

F = n => '5445054524413452545'[n] - 3
o = a => b => (n = F(b)) < 0 ? a * n : a + n
f = a => b => o(o(F(a))(b))

f(a)(b)(c)
  |  |  |
  |  |  +-- 'b' argument of the function returned by the outer call to 'o'
  |  +----- 'b' argument of the function returned by 'f'
  +-------- 'a' argument of 'f'

परीक्षण के मामलों

कोड स्निपेट दिखाएं

let f =

a=>b=>(o=a=>b=>(n=F(b))<0?a*n:a+n)(o((F=n=>'5445054524413452545'[n]-3)(a))(b))

console.log(f(3)(4)(4))     // =>  18
console.log(f(4)(4)(4))     // =>  -27
console.log(f(12)(12)(12))  // =>  0
console.log(f(0)(1)(2))     // =>  4
console.log(f(6)(4)(5))     // =>  -1
console.log(f(15)(1)(18))   // =>  2
console.log(f(18)(6)(11))   // =>  -6

स्निपेट का विस्तार करें

— Arnauld
स्रोत

1

कड़ाई से बोलते हुए, आप 1 तर्क ले रहे हैं और 1 तर्क लेने वाले फ़ंक्शन को वापस कर रहे हैं, एक फ़ंक्शन को लागू करने के लिए एक मान की गणना करता है जो 1 तर्क लेता है और एक फ़ंक्शन को 1 तर्क लेता है, और अंतिम फ़ंक्शन देता है ...

— नील

6

बेगुंज, 74 73 बाइट्स

>&:0`!#^_1g68*-^:0`!#v_+
^2112-212/11.012/212 >*
^   @.$<       >">"35*0p

यहाँ कोशिश करो! यह अजीब है कि मेरा कोड केवल इस एक दुभाषिया पर काम करता है।

दूसरी पंक्ति में मूल रूप से तालिका से सभी मान शामिल हैं। गैर-संख्यात्मक मान वास्तव में नकारात्मक मान हैं क्योंकि वे ASCII तालिका पर अंकों से पहले आते हैं। वहाँ थोड़ा तर्क है जो निर्धारित करता है कि संख्या नकारात्मक है या नहीं, और यदि है, तो यह संख्या परिणाम से गुणा होती है।

तीसरी पंक्ति के दाईं ओर पहले नंबर को प्रारंभ करता है। अगर मुझे ऐसा नहीं करना पड़ता, तो मैं बहुत सारे बाइट्स बचा सकता था।

6

PHP, 128 बाइट्स

$i="5445054524413452545";[,$a,$b,$c]=$argv;echo(bc.($i[$c]-3<0?mul:add))((bc.($i[$b]-3<0?mul:add))($i[$a]-3,$i[$b]-3),$i[$c]-3);

PHP, 138 बाइट्स

$d=decbin(506743);$i="5445054524413452545";[,$a,$b,$c]=$argv;echo(bc.($d[$c]?add:mul))((bc.($d[$b]?add:mul))($i[$a]-3,$i[$b]-3),$i[$c]-3);

ऑनलाइन संस्करण

विस्तारित

$d=decbin(506743);
$i="5445054524413452545";
[,$a,$b,$c]=$argv;
echo(bc.($d[$c]?add:mul))((bc.($d[$b]?add:mul))($i[$a]-3,$i[$b]-3),$i[$c]-3);

— जार्ग हुल्सरमैन
स्रोत

6

पायथन 2 , 123 110 107 बाइट्स

a,b,c=input()
s=[int(i)-3for i in'05445054524413452545']
n=s[a]
for i in s[b],s[c]:n=[n*i,n+i][n>0]
print n

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

-3 बाइट्स @ mathjunkie को धन्यवाद

— OVS
स्रोत

1

यहाँ एक बेहतर संस्करण है, 118 बाइट्स

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

2

5445054524413452545फिर घटाना 3 आप बाइट्स के टन बचा सकता है ।

— मैजिक ऑक्टोपस Urn

1

n=[n+i,n*i][i<0]लूप के अंदर आपको 3 बाइट्स बचाता है

— गणित जंकी

5

05AB1E , 29 बाइट्स

•6SÚ²ÄOÃ•6BS3-©¹è|v®yèD0‹i*ë+

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

•6SÚ²ÄOÃ•6BS3-©               # Push [2, 1, 1, 2, -3, 2, 1, 2, -1, 1, 1, -2, 0, 1, 2, -1, 2, 1, 2] and store.
               ¹è             # Get first score.
                 |v           # Iterate through remaining scores.
                   ®yèD0‹i*ë+ # Push score list, grab relevant score.
                              # If negative, multiply, else add.

यह वास्तव में आप के रूप में कई या के रूप में कुछ आदानों के लिए काम करता है, तो आप 4 या अधिक लक्षण या सिर्फ 2 के साथ कारों के साथ कार हो सकता है। यह जानबूझकर नहीं था, बस यह कैसे समाप्त हुआ।

— जादू ऑक्टोपस Urn
स्रोत

5

सीजेएम , 43 38 बाइट्स

q~[YXXY-3YXYWXX-2TXYWYXY]f={_W>42+c~}*

आगे सूची को संक्षिप्त करने का एक तरीका हो सकता है ...

0-आधारित अनुक्रमण का उपयोग करता है।

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

व्याख्या

यह कार्यक्रम इस तथ्य का उपयोग करता है कि कोई मान योगात्मक के बजाय गुणात्मक है यदि और केवल यदि इसका नकारात्मक।

q~                     e# Get the list from input
  [...]                e# Push the list of values for each ingredient. T=0, W=-1, 
                       e#   X=1, Y=2. 
       f=              e# Get the elements at the given indices 
         {             e# Reduce over this block:
          _W>          e#  Check if the second number is > -1 (returning 0 or 1)
             42+c      e#  Add the result to 42 and cast to a char. 
                       e#    (ASCII 42 is * and 43 is +)
                 ~     e#  Eval the char (* is multiply, + is add)
                  }*   e# (end block)

— बिजनेस कैट
स्रोत

अच्छी + *चाल!

— फलों को तोड़ना

3

लुआ, 140 131 बाइट्स

~~i={2,1,1,2,-3,2,1,2,-1,1,1,-2,0,1,2,-1,2,1,2}function f(a,b,c)loadstring(("print("..i[a].."+"..i[b].."+"..i[c]..")"):gsub('%+%-','*-'))()end~~

i={2,1,1,2,-3,2,1,2,-1,1,1,-2,0,1,2,-1,2,1,2}function f(a,b,c)x,y,z=i[a],i[b],i[c]v=y>0 and x+y or x*y;print(z>0 and v+z or v*z)end

— गप्पी
स्रोत

3

जावास्क्रिप्ट, 85 72 बाइट्स

a=a=>eval(a.map(x=>(b="5445054524413452545"[x]-3,b<0?"*":"+")+b).join``)

[a,b,c]
ETHproductions के लिए प्रारूप -13 बाइट्स में इनपुट लेता है

— गंजा बंटा
स्रोत

आप x=>(b="...",b<0?"*":"+")+bसे बचने के लिए कर सकते हैं return, मुझे लगता है। (इसके अलावा, आपको [... ]स्ट्रिंग्स पर इंडेक्सिंग कार्यों की आवश्यकता नहीं है )

— ETHproductions

@ETHproductions मुझे "अपेक्षित"; '' यह मेरा ब्राउज़र हो सकता है, a=a=>eval(a.map(x=>(b="5445054524413452545"[x]-3,b<0?"*":"+")+b)).join``)आपके लिए काम करता है ?

— बाल्ड बंता

आप एक अतिरिक्त मिल गया है )के बाद +b, मेरा मानना है कि

— ETHproductions

2

आर, 125 123 बाइट्स

function(a,b,c){v=c(5,4,4,5,0,5,4,5,2,4,4,1,3,4,5,2,5,4,5)-3
o=rep("+",19)
o[v<0]="*"
get(o[c])(get(o[b])(v[a],v[b]),v[c])}

अनाम फ़ंक्शन जो इनपुट के रूप में तीन पूर्णांक लेता है। मूल्यों और संचालन की एक सूची को परिभाषित करता है, और फिर केवल इनपुट द्वारा बुलाए गए लोगों का मूल्यांकन करता है, अर्थात o3(o2(v1,v2),v3)। ऐसा करने के लिए लगभग निश्चित रूप से एक गोल्फ खिलाड़ी है!

अद्यतन: कुछ फिर से काम करने के बाद, मेरे पास एक विकल्प है, 123 बाइट्स भी । फिर, एक अनाम फ़ंक्शन, लेकिन तीन मानों के एकल वेक्टर के रूप में इनपुट लेता है। समान दृष्टिकोण का उपयोग करता है, मूल्यों और संचालन की सूची को परिभाषित करता है और इसका मूल्यांकन करता है।

function(x,f=c(sum,prod)[x[-1]%in%c(5,9,12,16)+1],s=c(5,4,4,5,0,5,4,5,2,4,4,1,3,4,5,2,5,4,5)[x]-3)f[[2]](el(f)(s[-3]),s[3])

— rturnbull
स्रोत

2

हास्केल, 186 116 112 108 बाइट्स

o x|x<0=(*)|0<1=(+)
v=(map((-51+).fromEnum)"95445054524413452545"!!)
w [x,y,z]=(o z)((o y)x y)z
k=w.map v

मुख्य कार्य है k। कोड गोल्फ में नया तो मुझे यकीन है कि कुछ बाइट्स हैं जिन्हें मैं $ऑपरेटर बनाम कोष्ठक के चतुर उपयोग के साथ बंद कर सकता हूं । मैं शायद उत्तर को अपडेट कर दूंगा क्योंकि मैं सुधार करना जारी रखूंगा।

अनिवार्य रूप से इस तरह कार्यक्रम को तोड़ा जा सकता है:

v एक फ़ंक्शन है जो 1 आधारित सूचकांक लेता है और उस फूड आईडी का मूल्य लौटाता है।
o एक ऐसा कार्य है जो खाद्य मूल्य लेता है और उपयुक्त ऑपरेटर को लौटाता है (उदा। नकारात्मक मूल्य हमेशा वह होता है *जहां सकारात्मक मूल्य हमेशा होते हैं +)
w एक फ़ंक्शन है जो vइनपुट पूर्णांक के लिए मैप किए गए 3 आंशिक कार्यों की सूची लेता है और प्रत्येक से उचित संचालन और मूल्यों को प्राप्त करता है और उचित आउटपुट देता है।
k पॉइंट फ्री स्टाइल में मुख्य कार्य है जो v से इनपुट पर मैप करता है और आउटपुट को वापस करने के लिए w के लिए इस सूची को बनाता है।

अद्यतन करें

FromEnum चाल को इंगित करने के लिए विशेष धन्यवाद! कि अच्छी तरह से काम किया। इसके अलावा, मैंने नियमों में उस हिस्से को याद किया जिसमें स्वीकार्य समाधान एक फ़ंक्शन हो सकता है जो पूर्णांकों की सूची लेता है। इसने जबरदस्त काम बचाया।

अद्यतन २

अन्य सुझावों के अनुसार, संचालन को फिर से व्यवस्थित करके मुट्ठी भर बाइट्स का मुंडन किया, एक और गार्ड बनाया जो हमेशा ट्रू का मूल्यांकन करता है, और डब्ल्यू पर एक पैटर्न जो कि 3 तत्वों की सूची पर मेल खाता है। सुझाव के लिए धन्यवाद!

अद्यतन 3

अधिक कोड गोल्फ नियमों को इंगित करने के लिए लाइकोनी का एक और धन्यवाद जो मुझे पता नहीं था। आंशिक रूप से लागू कार्यों की सूची बनाने के लिए मेरे इनपुट के लिए v मैपिंग भी एक अभूतपूर्व विचार था और मुझे 4 अतिरिक्त बाइट्स बचाए!

— maple_shaft
स्रोत

1

विशेष रूप से PPCG और हास्केल गोल्फ में आपका स्वागत है! आप [Int] -> Intस्टड से पढ़ने और stdout को लिखने के बजाय एक फ़ंक्शन लिखकर बहुत से बाइट्स बचा सकते हैं । ऐसा करने की अनुमति डिफ़ॉल्ट रूप से दी जाती है, लेकिन इस मामले में इसका स्पष्ट रूप से चुनौती में उल्लेख किया गया है कि पूर्णांक की सूची को इनपुट के रूप में स्वीकार्य है।

— लकोनी

1

fromEnumइसके बजाय का उपयोग digitToIntकम होने की संभावना है क्योंकि यह आपको आयात को छोड़ने की अनुमति देता है।

— लकोनी

@ लिकोनी आपके कुछ नियमों की ओर इशारा करने के लिए आपका बहुत धन्यवाद, जिनके बारे में मुझे जानकारी नहीं थी! FromEnum ट्रिक ने भी एक आकर्षण की तरह काम किया, पता नहीं क्यों मैंने ASCII कोड से काम करने के बारे में नहीं सोचा लेकिन इससे बाइट्स की जबरदस्त बचत हुई।

— मेपल_शफ्ट

1

v=(map((-51+).fromEnum)"95 ... 5"!!)दो कोष्ठक बचाता है। o x|x<0=(*)|0<1=(+)दूसरे गार्ड में एक बाइट बचाता है।

— लकोनी

1

में wएक अतिरिक्त जगह बची है। इसके अलावा, जैसा कि आपको केवल लंबाई 3 की सूचियों को संभालने की आवश्यकता है, आप w[x,y,z]=पैटर्न मिलान के रूप में उपयोग कर सकते हैं ।

— लकोनी

0

हास्केल, 92 87 बाइट्स

x#y|x<0=(y*)|0<1=(y+)
k[x,y,z]=z#z$y#x$y
k.map([read[q]-3|q<-"95445054524413452545"]!!)

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

@ मेपल_शफ्ट के जवाब के आधार पर, मैंने इसे थोड़ा सा फैक्टर कर दिया।

5 बाइट्स के लिए @ लिकोनी को धन्यवाद!

— BlackCap
स्रोत

1

87 बाइट्स: इसे ऑनलाइन आज़माएं!

— लैकोनी

@ लैकोनी मुझे पूरा यकीन है कि

— नए अंक

मैंने दो बाइट्स की गणना इसलिए नहीं की f=क्योंकि अनाम कार्यों को प्रस्तुत करने की अनुमति है। उन्हें केवल tio उदाहरण कार्य करने के लिए आवश्यक है।

— लकोनी

0

सी, 171 161 बाइट्स

#include<stdio.h>
r,z[3],*a=z,i;f(x){i?x<0?r*=x:(r+=x):(r=x);}main(){scanf("%d %d %d",a,a+1,a+2);for(;i++<3;f("05445054524413452545"[*a++]-51));printf("%d",r);}

— पीटर लेनकेफी
स्रोत

0

8086 मशीन कोड, 62 बाइट्स

00000000  be 3b 01 31 c0 86 c4 ac  e8 0a 00 81 fe 3e 01 72  |.;.1.........>.r|
00000010  f4 b4 4c cd 21 bb 32 01  d0 e8 d7 73 03 c0 e0 04  |..L.!.2....s....|
00000020  c0 f8 04 e3 05 31 c9 c3  86 c4 78 03 00 e0 c3 f6  |.....1....x.....|
00000030  ec c3 21 12 d2 12 f1 1e  01 2f 12 00 00 00        |..!....../....|
0000003e

अंतिम तीन बाइट्स में (शून्य-अनुक्रमित) इनपुट होता है। अरे, आपने मुझे बताया कि मैं सबसे सुविधाजनक इनपुट प्रारूप का उपयोग कर सकता हूं। इस मामले में, यह हार्डकोडिंग है!
आउटपुट शेल में दिया गया त्रुटि कोड है।

यह काम किस प्रकार करता है:

            |   org 0x100
            |   use16
be 3b 01    |       mov si, input   ; source = input
31 c0       |       xor ax, ax      ; clear ax
86 c4       |   @@: xchg al, ah     ; swap al/ah (ah = total value)
ac          |       lodsb           ; al = *si++
e8 0a 00    |       call fn
81 fe 3e 01 |       cmp si, input+3 ; end of input?
72 f4       |       jb @b           ; repeat if not
b4 4c       |       mov ah, 0x4c    ; dos function: exit with al=error code
cd 21       |       int 0x21        ; syscall
            |
bb 32 01    |   fn: mov bx, table   ; pointer to lookup table
d0 e8       |       shr al, 1       ; divide input by 2
d7          |       xlatb           ; al = *(bx + al)
73 03       |       jnc @f          ; skip next instruction if input was odd
c0 e0 04    |       shl al, 4       ; shift low nibble to high nibble
c0 f8 04    |   @@: sar al, 4       ; shift high nibble to low nibble with sign-extension
e3 05       |       jcxz @f         ; return if cx is non-zero (only happens for the first input)
31 c9       |       xor cx, cx      ; clear cx
c3          |       ret
86 c4       |       xchg al, ah     ; swap al/ah (al = total value)
78 03       |   @@: js @f           ; multiply if negative, add if positive
00 e0       |       add al, ah      ; al = al+ah
c3          |       ret
f6 ec       |   @@: imul ah         ; ax = al*ah
c3          |       ret
21 12 d2 12 |   table db 0x21, 0x12, 0xd2, 0x12, 0xf1, 0x1e, 0x01, 0x2f, 0x12
f1 1e 01 2f |                       ; each value is stored in a 4-bit nibble
12          |
00 00 00    |   input db 3 dup(0)

— user5434231
स्रोत

कितनी तेज है मेरी हॉट व्हील्स कार?

जेली , 24 बाइट्स

कैसे?

जावास्क्रिप्ट (ईएस 6), 89 84 82 78 73 बाइट्स

परीक्षण के मामलों

पिछला संस्करण, 78 बाइट्स

यह काम किस प्रकार करता है

परीक्षण के मामलों

बेगुंज, 74 73 बाइट्स

PHP, 128 बाइट्स

PHP, 138 बाइट्स

पायथन 2 , 123 110 107 बाइट्स

05AB1E , 29 बाइट्स

सीजेएम , 43 38 बाइट्स

लुआ, 140 131 बाइट्स

जावास्क्रिप्ट, 85 72 बाइट्स

आर, 125 123 बाइट्स

हास्केल, 186 116 112 108 बाइट्स

हास्केल, 92 87 बाइट्स

सी, 171 161 बाइट्स

8086 मशीन कोड, 62 बाइट्स