42

बीन मशीन या प्लिन्को / पचिनको गेम के समान एक तंत्र के इस ASCII संस्करण पर विचार करें :

    O

    ^
   \ ^
  ^ ^ \
 \ ^ / ^
U U U U U
1 2 3 4 5

Oएक गेंद है कि नीचे गिर जाता है है।

जब यह एक हिट करता है ^, तो 50-50 मौका होता है यह बाएं या दाएं जाएगा।
जब यह एक हिट करता है /, तो यह हमेशा बाएं जाता है।
जब यह हिट होता है \, तो यह हमेशा सही होता है।

गेंद अंत में Uनीचे गिने कुंडों में से एक में गिरती है । सवाल यह है कि प्रत्येक गर्त में यह क्या संभावना है?

इस विशेष मामले के लिए, संभावनाओं हैं 0.0, 0.1875, 0.5625, 0.125, और 0.125क्रमश: 5 के माध्यम से troughs 1 के लिए।

यहाँ 5. संभावनाओं हैं बजाय 3 troughs के साथ एक और उदाहरण 0.5, 0.5और 0.0:

  O

  /
 ^ ^
U U U
1 2 3

इस चुनौती में हम इस समस्या को किसी भी फैशन में स्थापित परतों की संख्या के साथ एक तंत्र के लिए सामान्य करेंगे।

चुनौती

एक प्रोग्राम या फ़ंक्शन लिखें जो तंत्र के पिरामिड संरचना के एएससीआईआई प्रतिनिधित्व में लेता है। (स्टड / कमांड लाइन / फंक्शन arg के माध्यम से इनपुट।)

आप मान सकते हैं कि यह रिक्त स्थान के साथ आता है जो इसे उचित आकार में रखता है, जैसे

   ^
  \ ^
 ^ ^ \
\ ^ / ^

या आप मान सकते हैं कि यह बिना किसी स्थान के साथ आता है, जैसे

^
\^
^^\
\^/^

(यदि वांछित है, तो आप मान सकते हैं कि एक अनुगामी न्यूलाइन और / या अनुगामी रिक्त स्थान के कुछ सुसंगत पैटर्न हैं।)

इनपुट पिरामिड संरचना में शून्य सहित किसी भी स्तर (उर्फ लाइनें) हो सकती हैं। प्रत्येक स्तर पर एक और है ^, /या \पिछले की तुलना में, और देखते हैं levels + 1तल पर नली (जो इनपुट का हिस्सा नहीं हैं)।

आपको प्रोग्राम / फ़ंक्शन को उन संभावितताओं की सूची को प्रिंट / वापस करना होगा जो गेंद प्रत्येक गर्त में (भूमि क्रम में सबसे निचले गर्त से दाएं गर्त में) है। ये फ़्लोटिंग पॉइंट मान होने चाहिए, जो मुद्रित होने पर, कम से कम 3 दशमलव स्थान हों (सुपरफ़्लोस ज़ीरोस या दशमलव अंक की आवश्यकता नहीं है; के 1लिए ठीक है 1.000, के .5लिए ठीक है 0.500, आदि)। यदि आपने एक फ़ंक्शन लिखा है, तो आप मानों को प्रिंट कर सकते हैं या फ़्लोट्स की एक सूची / सरणी लौटा सकते हैं।

कोई भी उचित मुद्रित सूची प्रारूप ठीक है। जैसे 0.5 0.5 0.0, [0.5 0.5 0.0], [0.5, 0.5, 0.0], {0.5, 0.5, 0.0}, या 0.5\n0.5\n0.0सब ठीक हो जाएगा।

उदाहरण

0 के स्तर: (एक तुच्छ नीचे फोड़े U)

इनपुट: [no input/empty string given]
आउटपुट:1.0

1 स्तर:

इनपुट: ^
आउटपुट:0.5 0.5

इनपुट: /
आउटपुट:1.0 0.0

इनपुट: \
आउटपुट:0.0 1.0

2 स्तर: (ऊपर दूसरा उदाहरण)

इनपुट:

 /
^ ^

आउटपुट: 0.5 0.5 0.0

3 स्तर:

इनपुट:

  ^
 ^ ^
^ ^ ^

आउटपुट: 0.125 0.375 0.375 0.125

इनपुट:

  \
 / \
/ / \

आउटपुट: 0.0 0.0 0.0 1.0

4 स्तर: (पहला उदाहरण ऊपर)

इनपुट:

   ^
  \ ^
 ^ ^ \
\ ^ / ^

आउटपुट: 0.0 0.1875 0.5625 0.125 0.125

7 स्तर:

इनपुट:

      ^
     / ^
    ^ ^ /
   / \ / \
  ^ ^ / ^ \
 ^ \ ^ \ / ^
\ ^ ^ ^ \ ^ /

आउटपुट: 0.0 0.09375 0.28125 0.4375 0.1875 0.0 0.0 0.0

स्कोरिंग

बाइट्स जीत में सबसे छोटा जवाब। टाईब्रेकर पहले की पोस्ट है।

code-golf probability-theory

— केल्विन के शौक
स्रोत

16

Quincunx के पास इसका बेहतर जवाब था।

— केल्विन के शौक

"रिक्त स्थान के कुछ सुसंगत पैटर्न" - क्या मैं मान सकता हूं कि Nth लाइन पर अनुगामी रिक्त स्थान गेंद के Nth बाल्टी में उतरने की संभावना को कूटबद्ध करता है?

— रैंडम 832

4

@ Random832 संख्या (क्या आप वास्तव में लगता है कि उड़ान भरने के हैं?)

— केल्विन के शौक

एक कारण है कि मैंने इसे उत्तर के बजाय टिप्पणी के रूप में पोस्ट किया है। मुझे लगा कि यह दिलचस्प था कि यह पहेली इनपुट के बारे में कितनी सहज थी - सबसे ज्यादा मैंने इनपुट और / या आउटपुट के प्रारूप को सख्ती से देखा है।

— रैंडम 832

@ Random832: इनपुट और आउटपुट बहुत अस्पष्ट हैं। मानक खामियों (जैसे इनपुट में जवाब को एन्कोडिंग) को हर चुनौती में संबोधित करने की आवश्यकता नहीं है।

— एलेक्स ए

10

CJam, 50 48 45 44 42 40 बाइट्स

1]q{iD%"(+0 0+( (\Y/::+ (d2/_a+"S/=~+}/p

यह इनपुट को अंतरिक्ष के बिना होने की उम्मीद है और एक अनुगामी न्यूलाइन है। उदाहरण के लिए:

^
\^
^^\
\^/^

[0 0.1875 0.5625 0.125 0.125]

कलन विधि

मूल विचार यह है कि आप प्रत्येक वर्ण को पार्स करते रहते हैं (केवल 4 अलग-अलग वर्ण हैं) और प्रायिकता वितरण पर अलग-अलग ऑपरेशन करते हैं (शुरुआत में एक मान जिसमें 1 तत्व 1 का मान होता है)। इनपुट वर्णों की प्रत्येक पंक्ति (पहली पंक्ति पर पहले वर्ण के साथ शुरू) के लिए, हम उसी आकार की प्रायिकता सरणी बनाए रखते हैं। प्रत्येक चरित्र सूची से पहली संभावना पर कार्य करता है और परिणामी जोड़ी को सूची के अंत तक धकेलता है। प्रत्येक पंक्ति के बाद, हम अगली पंक्ति में आइटम के रूप में आइटम की सटीक संख्या प्राप्त करने के लिए सूची से जोड़े को जोड़ते हैं।

यहां प्रत्येक के लिए चार वर्ण और आवश्यक क्रियाएं हैं:

^: जब यह चरित्र होता है, तो आप वर्तमान संभाव्यता को दो भागों में विभाजित करते हैं। उदाहरण के लिए, यदि हमारे पास यह पहली पंक्ति में है, तो हमें इसे परिवर्तित करना [1]होगा[0.5 0.5]
/: जब यह वर्ण होता है, तो हमें <current probability> 0सरणी में वर्तमान संभाव्यता के स्थान पर रखना होगा ।
\: जब यह वर्ण होता है, तो हमें 0 <current probability>सरणी में वर्तमान संभाव्यता के स्थान पर रखना होगा ।
\n: जब यह चरित्र होता है, तो हमारे पास एक नई पंक्ति होती है। इस प्रकार हम 3 वर्णों से ऊपर के सभी जोड़ों को एक साथ जोड़ते हैं और अगली पंक्ति के लिए प्रत्येक आइटम की प्रायिकता प्राप्त करने के लिए उन्हें जोड़ते हैं। पूर्व के लिए। [0 0.5 0.25 0.25]में परिवर्तित हो जाता है [0 0.75 0.25]। ध्यान दें कि पहले और अंतिम आइटम में पहले और बाद में एक अंतर्निहित जोड़ी (मूल्यवान 0) है।

अब हमें केवल सही चरित्र की पहचान करनी है और सही कार्य करना है। ऐसा करने के लिए यहाँ सामान्य गणित का उपयोग करें। के लिए ASCII कोड ^, \, /और \nकर रहे हैं 94, 92, 47, और 10। कुछ परीक्षणों के बाद, हमें इन संख्याओं को 0, 1, 2 और 3 में बदलने के लिए यह सरल समीकरण मिलता है:

"^\/
":ied13f%ed4f%ed

देता है:

Stack: [[94 92 47 10]]
Stack: [[3 1 8 10]]
Stack: [[3 1 0 2]]
3102

लंबाई 4 की एक सरणी में, अंतिम 4f%निहित होगा। तो हम बस %13चरित्र के ASCII कोड के लिए करते हैं और कार्यों की एक सरणी से सही कार्रवाई का चयन करते हैं।

कोड स्पष्टीकरण :

1]                                 e# Initial probability array with 1 probability
  q{                          }/   e# Read the whole input and iterate char by char
    iD%                            e# mod the ASCII code of the character with 13
"(+0 0+( (\Y/::+ (d2/_a+"S/        e# This is our actions array in order of [\ / \n ^]
                           =~      e# We pick the correct action and eval it
                             +     e# Evaling each action will leave one number out of the
                                   e# pairs out of the array. So we put it back in
                                p  e# Print the final probability array

इसे यहाँ ऑनलाइन आज़माएँ

— अनुकूलक
स्रोत

1

आप इसे 0 पंक्तियों के साथ कैसे परखेंगे?

— ट्राइकोप्लाक्स

1

@trichoplax को अब काम करना चाहिए।

— ऑप्टिमाइज़र

यह अब खाली इनपुट के साथ काम करता है :)

— ट्राइकोप्लाक्स

15

रूबी 140

->s{r=[1.0]
s.lines.map{|l|n=[i=0.0]*(r.size+1)
l.scan(/\S/).map{|e|a,b=e>?/?e>?]?[0.5]*2:[0,1]:[1,0]
z=r[i]
n[i]+=z*a
n[i+=1]+=z*b}
r=n}
r}

स्ट्रिंग के रूप में कार्य करने वाला फ़ंक्शन (पिरामिड के रूप में अच्छी तरह से स्वरूपित किया जा सकता है) और फ़्लोट्स की एक सरणी देता है।

इसे ऑनलाइन टेस्ट करें: http://ideone.com/kmsZMe

बहुत सीधा-सादा अमल। यहाँ यह अपुष्ट है:

F = -> input {
  probabilities = [1.0]

  input.lines.each { |line|

    new_probabilities = [0.0] * (probabilities.size+1)
    elements = line.scan /\S/
    elements.map.with_index{|el, i|
      deltas = el > '/' ? (el > ']' ? [0.5,0.5] : [0,1]) : [1,0]

      d1, d2 = deltas

      new_probabilities[i] += probabilities[i] * d1
      new_probabilities[i + 1] += probabilities[i] * d2
    }
    probabilities = new_probabilities
  }
  return probabilities
}

— क्रिस्टियन लुपस्कू
स्रोत

13

रूबी, 140 158 बाइट्स

~~जब कोई बेहतर माणिक संस्करण हो तो इसे न रखें ।~~ यहां आपके लिए और ट्रिक्स हैं।

एक तर्क के साथ कार्य करें। कोई रिक्त स्थान नहीं होना चाहिए। मई या एक अनुगामी newline शामिल नहीं हो सकता है।

->s{Z=(s.split'
')<<[]
K=[]
F=->i,j,f{k=Z[i][j]
K[i]||=0
k==?^?2.times{|m|F[i+1,j+m,f/2]}:!k ?K[j]+=f :F[i+1,j+(k==?/?0:1),f]}
F[0,0,1.0]
K}

~~हैंडल 0 levels(खाली स्ट्रिंग) होने पर 9 बाइट्स बर्बाद करता है ।~~ सभी परीक्षण मामले सही ढंग से काम करते हैं, यहां आइडोन देखें ।

— blutorange
स्रोत

4

सिर्फ इसलिए कि "बेहतर" रूबी जवाब का मतलब आपका (या उस मामले के लिए कोई अन्य रूबी जवाब) वोट के लायक नहीं है। :)

— एलेक्स ए

मैंने इसे स्वयं उकेरा क्योंकि इसमें कुछ अच्छी तरकीबें हैं। splitउदाहरण के लिए मुझे आपकी बहुस्तरीय पसंद है ।

— क्रिस्टियन लुपस्कू

12

पायथ, 43 42 41 बाइट्स

umsdc+0sm@c[ZJhkJZKcJ2K)2x"\/"ekC,GH2.z]1

यह इनपुट को रिक्त स्थान के बिना होने की उम्मीद करता है। इसे ऑनलाइन आज़माएं: पायथ कंपाइलर / एक्ज़ीक्यूटर

पायथ, 40 बाइट्स (संदिग्ध)

umsdc+0sm,K@[ZJhkcJ2)x"\/"ek-JKC,GH2.z]1

@ बसाक को धन्यवाद, एक बाइट बचाने के लिए। ध्यान दें कि यह संस्करण वास्तव में Pyth के संस्करण में काम नहीं करता था, जब प्रश्न पूछा गया था। संकलक में एक छोटा बग था। इस कोड के बावजूद Pyth की कोई नई विशेषता (केवल सामान जो Pyth डॉक्स में लंबे समय तक थी और काम करना चाहिए था) का उपयोग करता है, यह एक मान्य उत्तर नहीं हो सकता है। अपने लिए तय करें।

इसे ऑनलाइन आज़माएं: पायथ कंपाइलर / एक्ज़ीक्यूटर

स्पष्टीकरण:

umsdc+0sm,K@[ZJhkcJ2)x"\/"ek-JKC,GH2.z]1   
u                                   .z]1  reduce G, starting with G = [1], for H in all_input():
                               C,GH         zip(G,H)
        m                                   map each pair k to:
            [ZJhkcJ2)                         create a list [0, k[0], k[0]/2]
                     x"\/"ek                  index of k[1] in "\/" (-1 for "^")
          K@                                  take the correspondent element of the list and store in K
         ,                  -JK               create a pair (K, k[0]-K)                                                      
     +0s                                    sum and insert 0 at the begin
    c                              2        chop into pairs
 msd                                        sum up each pair
                                            G gets updated with this new list

उदाहरण के लिए यदि मेरे पास वर्तमान में इनपुट संभावनाएं हैं G = [0.5, 0.5, 0.0]और पंक्ति H = "^/^"निम्न होती है:

जिप ... [(0.5,"^"), (0.5,"/"), (0.0,"^")]
आउटपुट संभावनाएँ बनाएँ ... [[0.25,0.25], [0.5,0.0], [0.0, 0.0]]
0 + राशि ... [0, 0.25, 0.25, 0.5, 0.0, 0.0, 0.0]
काटना ... [0,0.25], [0.25,0.5], [0.0,0.0], [0.0]]
राशि ... [0.25, 0.75, 0.0, 0.0]

— Jakube
स्रोत

3

मैं इसे गोल्फ करने की कोशिश कर रहा था, और इसने मुझे कंपाइलर में एक बग में ले जाया। गोल्फ काम करता है, अब जब मैंने बग को ठीक कर लिया है। गोल्फ एक सूची के साथ 2-मूल्य सूचियों की सूची को बदलना है, और फिर पहले मूल्य को घटाकर दूसरे मूल्य को उत्पन्न करना है hk। ,K@[ZJhkcJ2)x"\/"ek-JK

— isaacg

1

यह वास्तव में एक ठीक रेखा है जब आप बग को ठीक कर रहे हैं, भाषा के नए संस्करण के रूप में नहीं गिना जा रहा है (और इस प्रकार अभी भी तय किए गए प्रश्नों के लिए वैध है)

— ऑप्टिमाइज़र

1

@ अधिकार आपका अधिकार। उत्तर में कुछ नोट्स जोड़े, जो परिस्थितियों को बताते हैं।

— जकुबे

2

@Optimizer इस मामले में, ऐसा लगता है कि अंगूठे का एक अच्छा नियम यह है कि क्या यह वास्तव में भाषा का एक नया संस्करण है या भाषा कार्यान्वयन का एक नया संस्करण है जो बग को ठीक करता है, कार्यान्वयन के साथ कल्पना के करीब लाता है।

— Desty

@Desty इसलिए मैंने उल्लेख किया है कि इसकी एक अच्छी रेखा है;)

— ऑप्टिमाइज़र

8

सी #, 274 247 बाइट्स

कुछ भी नहीं फैंसी, पूरा कार्यक्रम जो एसटीडीआईएन से लाइनों को पढ़ता है (रिक्त स्थान के साथ या इसके बिना, यह बस उन्हें स्ट्रिप्स करता है) और स्पेस स्पेस ने एसटीडीयूएसटी को अलग कर दिया।

using Q=System.Console;class P{static void Main(){decimal[]k={1},t;string L;for(int l=0,i;(L=Q.ReadLine())!=null;k=t)for(L=L.Replace(" ",""),t=new decimal[++l+1],i=0;i<l;)t[i]+=k[i]-(t[i+1]=(8-L[i]%8)/2*k[i++]/2);Q.WriteLine(string.Join(" ",k));}}

टिप्पणियों के साथ Tidier कोड:

using Q=System.Console;

class P
{
    // / 47
    // \ 92
    // ^ 94

    static void Main()
    {
        decimal[]k={1},t; // k is old array, t is new array

        string L; // L is the current line, R is the current result (1 if no rows)
        for(int l=0,i; // l is length of old array, i is index in old array
            (L=Q.ReadLine())!=null; // for each line of input
            k=t) // swap array over
            for(L=L.Replace(" ",""), // remove spaces
                t=new decimal[++l+1], // create a new array
                i=0;

                i<l;) // for each position

                t[i]+=k[i]-( // add to left position (for last time)
                        t[i+1]=(8-L[i]%8)/2*k[i++]/2 // assign right position (k is decimal)
                    );

        Q.WriteLine(string.Join(" ",k)); // print result
    }
}

— VisualMelon
स्रोत

7

अजगर 3, 113

P=[1]
for C in input().split():
 l,*Q=0,
 for p,c in zip(P,C):r=p*"\^/".find(c)/2;Q+=l+r,;l=p-r
 P=Q+[l]
print(P)

बार-बार Pप्रत्येक लाइन के जवाब में प्रायिकता वेक्टर को अपडेट करता है । इस नए प्रायिकता वेक्टर Qको एक बार में एक प्रविष्टि बनाया जाता है। नए स्लॉट के माध्यम से Iterates, और खूंटी से अपने दाईं ओर योगदान की गणना करता है r, जबकि आगामी स्लॉट के लिए शेष योगदान की गणना भी करता है p-r।

प्रत्येक पंक्ति में एक बैकस्लैश में रेखाएँ समाप्त होने वाली समस्या से बचने के लिए कम से कम एक स्थान पर समाप्त होने की अपेक्षा करता है।

— XNOR
स्रोत

इनपुट में कई लाइनें होंगी इसलिए मुझे नहीं लगता कि कोई भी input()इसे संभाल सकता है।

— यादृच्छिक

इनपुट की प्रत्येक पंक्ति के लिए एक अनुगामी न्यूलाइन की आवश्यकता नहीं है।

— ब्रायन मिंटन

@randomra मैंने इसे आइडल में लिखा था और इसने शेल प्रॉम्प्ट में मल्टी-लाइन इनपुट में ठीक काम किया।

— xnor

6

पायथन 3, 138 बाइट्स

def f(s):
 r=[1];p=t=0
 for e in s:
  if'!'<e:b=p==t*-~t/2;r+=[0]*b;t+=b;v=ord(e)%7+1;a=r[p]/2;r[-1]+=v//3*a;r+=v%3*a,;p+=1
 return r[~t:]

किसी भी व्हाट्सएप के साथ काम करता है क्योंकि वे सभी (बाहर if'!'<e) फ़िल्टर किए जाते हैं ।

तरीका:

हम rकिसी भी बाधाओं और उनके नीचे निहित गर्तों तक पहुँचने की संभावनाओं की एक विस्तृत विस्तार सूची रखते हैं। हम सूची से शुरू करते हैं [1]।
यदि हम एक पंक्ति में पहली बाधा पर हैं तो हमें 0अग्रणी गर्त के लिए सूची में एक अतिरिक्त जोड़ना होगा । हम यह तय करते हैं कि यह pअगले त्रिकोणीय संख्या में अपने सूचकांक की तुलना करके पहली बाधा है t*-~t/2।
प्रत्येक बाधा के लिए हम आंशिक रूप से अंतिम तत्व और आंशिक रूप से एक नए अनुगामी तत्व में इसकी सूची-मूल्य जोड़ते हैं। हम बाधा चरित्र ( ^:0.5 0.5; /:1 0; \:0 1) के आधार पर सूची-मूल्य को विभाजित करते हैं । हम निम्नलिखित विधि का उपयोग करते हैं:
- v = ord(char) mod 7 + 1उपज ले लो^:4 /:6 \:2
- v div 3 / 2पहला अंश पैदावार ( ^:0.5 /:1 \:0)
- v mod 3 / 2दूसरा अंश पैदावार ( ^:0.5 /:0 \:1)
परिणाम t + 1अंतिम सूची के अंतिम तत्व हैं r।

2 बाइट्स @ Sp3000 की चैट सलाह के लिए धन्यवाद।

— randomra
स्रोत

4

पर्ल, 78

#!perl -p0a
@r=($/=1);$^=.5;@r=map$r-$l+($l=$$_*($r=shift@r)),/./g,$r=$l=0for@F;$_="@r"

रिक्त स्थान के बिना इनपुट लेता है।

मुझे आजमाओ ।

— nutki
स्रोत

1

टीआई-बेसिक, 73 76

एक समय में एक लाइन इनपुट करता है, और जब अंतरिक्ष अपने आप में प्रवेश करता है, तो समाप्त हो जाता है, क्योंकि न तो तार स्ट्रिंग में टूटता है और न ही खाली तार TI-BASIC में कानूनी हैं।

{1→X
Input Str1
While Str1≠"  //one space
.5seq(inString("^/",sub(Str1,I,1)),I,1,dim(Ans
augment(Ans∟X,{0})+augment({0},∟X-∟XAns→X
Input Str1
End
∟X

मुझे पूरा यकीन है कि मुझे आकार सही मिला (TI-BASIC एक टोकन है, इसलिए प्रत्येक कमांड में एक या दो बाइट्स लगते हैं- seq () में एक लेता है, inString () में दो लगते हैं, डिम) और एक लेता है।) मैन्युअल रूप से आकार गिना।)

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

— lirtosiast
स्रोत

0

जावास्क्रिप्ट - 117

पुनरावृत्ति का उपयोग करने की कोशिश की, लेकिन वह बहुत लंबा था ...

घटाव विचार के लिए xnor के लिए टोपी टिप , जो एक दर्जन या अधिक वर्णों से मुंडा।

w=s=>{a=[1];s.split('\n').map(m=>{for(b=[i=0];z=a[i],f=m[i];b[i++]+=z-b[i])b[i+1]=f>']'?z/2:f<':'?0:z;a=b})
return a}

Ungolfed:

// s must not have spaces
w=s=>{
  // a is the current probability array
  a=[1];
  s.split('\n').map(
    // for each row of input...
    m=>{
      b=[0];  // b is the next row's probability array
      for(i=0; i<m.length;){
        z=a[i]; // z = probability
        f=m[i]; // f = letter
                                  // let's assume i == 0
        b[i+1] = (f>']') ? z/2 :  // if f == '^', b[1] = z/2
          (f<':' ? 0 :            // else if f == '/', b[1] = 0 
            z);                   // else b[1] = z
        b[i++]+=z-b[i];           // then add (z-b[1]) to b[0]
      }
      a=z-b    // increment current probability array
    }
  )
  return a;
}

— चार्ल्स नहीं
स्रोत

आपका रूटीन बीन मशीन नहीं

चुनौती

उदाहरण

स्कोरिंग

CJam, 50 48 45 44 42 40 बाइट्स

रूबी 140

रूबी, 140 158 बाइट्स

पायथ, 43 42 41 बाइट्स

पायथ, 40 बाइट्स (संदिग्ध)

स्पष्टीकरण:

सी #, 274 247 बाइट्स

अजगर 3, 113

पायथन 3, 138 बाइट्स

पर्ल, 78

टीआई-बेसिक, 73 76

जावास्क्रिप्ट - 117