कार्य

एक को देखते हुए गैर खाली की सरणी 0और 1, के रनों की लंबाई आधा करना 0।

इनपुट

की एक सरणी 0और 1। स्वीकार्य प्रारूप:

अपनी भाषा में वास्तविक सरणी
लाइनफीड-पृथक स्ट्रिंग 0और1
से सटे स्ट्रिंग 0और1
कोई अन्य उचित प्रारूप

उदाहरण के लिए, निम्नलिखित तीन इनपुट सभी स्वीकार्य हैं:

[1, 0, 0, 1]
"1\n0\n0\n1"(कहां \nलाइनफीड U + 000A है)
"1001"

आप मान सकते हैं कि रनों की लंबाई भी0 होगी ।

उत्पादन

ऊपर के स्वीकार्य स्वरूपों में 0और की एक सरणी 1।

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

input ↦ output
[1,0,0,1,0,0,1] ↦ [1,0,1,0,1]
[1,1,0,0,1,1,0,0,1] ↦ [1,1,0,1,1,0,1]
[1,1,0,0,1,1,1,0,0,1,1] ↦ [1,1,0,1,1,1,0,1,1]
[1,1,1] ↦ [1,1,1]
[0,0,1] ↦ [0,1]
[0,0] ↦ [0]
[1,1,1,0,0,0,0,1,1,1,1,0,0,1,0,0,1,1,0,0,1,1,1,1,0,0,1,0,0] ↦ [1,1,1,0,0,1,1,1,1,0,1,0,1,1,0,1,1,1,1,0,1,0]

स्कोरिंग

यह कोड-गोल्फ है । बाइट्स जीत में सबसे छोटा जवाब।

मानक खामियां लागू होती हैं।

code-golf array-manipulation

— लीक नन
स्रोत

पिछले टेस्टकेस में, शून्य के रन की लंबाई भी नहीं है?

— OldBunny2800

@ OldBunny2800 परीक्षण मामले को ध्यान से पढ़ें; 0-रन लंबाई 4, 2, 2, 2, 2 है, और 2.

— HyperNeutrino

हम ले सकते हैं trueऔर के falseबजाय 1और 0?

— साइओस

@ कौन सी भाषा है?

— लीक नून

@LeakyNun रूबी, जिसे सत्य मानता 0है।

— साइयो

27

रेटिना , 4 बाइट्स

00
0

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

— मार्टिन एंडर
स्रोत

इस एक को हराना मुश्किल होगा।

— एडम

@ Adám मुझे हरा पाना असंभव होगा।

— एग्री आउटलोफर

QuadR में भी काम करता है!

— अदाम

11

05AB1E , 5 बाइट्स

00¤.:

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

व्याख्या

00     # push 00
  ¤    # tail, pushes 0
   .:  # replace

— Emigna
स्रोत

2

वह तो आसान था; मैंने ऐसा क्यों नहीं सोचा?

— लीक नून

00अजीब व्यवहार है ...

— द एग्रीकल्चर

@EriktheOutgolfer: अनुक्रमिक अंकों को एक संख्या बनाने के लिए समवर्ती किया जाता है, इसलिए 11ग्यारह और नहीं है 1,1। इसका एक 00000,0

— दुष्परिणाम

@Emigna मुझे उम्मीद है कि यह बन जाएगा 0या 0 0इसके बजाय, लेकिन जो भी हो।

— एग्रीगेटर से एरिक

7

हास्केल , 33 बाइट्स

f(0:0:r)=0:f r
f(x:r)=x:f r
f e=e

इसे ऑनलाइन आज़माएं! उपयोग: f[1,1,0,0,1,1,0,0,1]। सूची में Iterates और एक शून्य से दो लगातार शून्य बदलता है।

— Laikoni
स्रोत

मुझे लगता है कि यह प्रोलॉग

— लीकी नून

7

सी (जीसीसी) , 35 बाइट्स

f(char*s){while(*s)putchar(*s),*s++-48?:s++;}

48 '0' का ascii कोड है

नील द्वारा सुझाए गए अनुसार बेहतर संस्करण 43 बाइट्स

f(char*s){while(*s)putchar(*s),s+=2-*s%2;}

इस बार एक और 40 बाइट (फिर से नील और विजुअलमेल द्वारा सुझाए गए) :)

f(char*s){for(;*s;s+=50-*s)putchar(*s);}

और फिर 35 बाइट्स खालिद के लिए धन्यवाद

f(char*s){*s&&f(s+50-putchar(*s));}

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

— Alkano
स्रोत

1

चाहेंगे s+=2-*s%2काम करते हैं?

— नील

1

अगर मैं सही ढंग से गिना जाता हूं तो मुझे लगता for(;*s;s+=2-*s%2)putchar(*s);है कि एक और बाइट बचाता है।

— नील

1

इसमें क्या गलत होगा s+=50-*s? उम्र के लिए सी नहीं किया गया और अपरिभाषित व्यवहार (जहां # कोई नहीं है से आ रहा है) को आमंत्रित करके खुद को शर्मिंदा नहीं करना चाहता

— विजुअलमेलन

1

putcharडॉक्स को देखते हुए , क्या आप कर सकते हैं f(char*s){for(;*s;s+=50-putchar(*s));}?

— विजुअलमेल

3

आप इसे पुनरावर्ती बनाकर 5 बाइट बचा सकते हैंf(char*s){*s&&f(s+50-putchar(*s));}

— खालिद.के

6

sed , 8 बाइट्स

s/00/0/g

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

— betseg
स्रोत

2

@boboquack काम नहीं करता है, क्योंकि यह हमेशा 0एस के एक रन को बदल देगा 0।

— एरिक आउटगॉल्फ

6

ऑक्टेव, 22 बाइट्स

@(s)strrep(s,'00','0')

सभी परीक्षण मामलों को यहां सत्यापित करें।

यह एक अनाम फ़ंक्शन है जो '1001000011'इनपुट के रूप में प्रारूप पर एक स्ट्रिंग लेता है, और एक शून्य के साथ दो लगातार शून्य को बदलता है।

— स्टीवी ग्रिफिन
स्रोत

6

जावा, 50 बाइट्स

String f(String s){return s.replaceAll("00","0");}

ऑनलाइन प्रयास करें

— Khaled.K
स्रोत

1

एक बहुत अच्छा इनपुट विकल्प! वैसे, यदि आप जावा 8+ समाधान पर स्विच करने में रुचि रखते हैं, तो आप लैम्बडा का उपयोग कर सकते हैं s->s.replaceAll("00","0"):।

— जैकब

इससे भी बेहतर, 3 बाइट्स को बचाने के replaceबजाय उपयोग करेंreplaceAll

— बेंजामिन Urquhart

@BenjaminUrquhart replaceकेवल पहली घटना को प्रतिस्थापित करेगा

— खालिद.के

@ जावास्क्रिप्ट में Khaled.K, हाँ। जावा में, यह सभी घटनाओं को प्रतिस्थापित करता है

— बेंजामिन अर्कहार्ट

5

हास्केल , 28 बाइट्स

f(h:t)=h:f(drop(1-h)t)
f e=e

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

पुनरावर्ती पहले तत्व को लेता है, दूसरे को छोड़ता है यदि पहले एक शून्य है, जब तक कि खाली की सूची नहीं है। यदि पहली प्रविष्टि है h, तो पहले 1-hको शेष से हटा दिया जाता है।

— XNOR
स्रोत

5

जाप , 7 6 5 बाइट्स

d'0²0

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

बस इनपुट में दो शून्य के प्रत्येक रन को एक शून्य से बदल देता है। स्ट्रिंग इनपुट (यानी "1001001") का उपयोग करता है ।

— ल्यूक
स्रोत

1

अच्छा! आपको 'मेरे विचार से भी इसकी आवश्यकता नहीं है

— ETHproductions

ऊह, आप :-) के "00"साथ प्रतिस्थापित करके एक और बाइट बचा सकते हैं'0²

— ETHproductions

खैर, यह अजीब है। हालांकि धन्यवाद!

— ल्यूक

4

पीएचपी, २६

<?=strtr($argn,["00"=>0]);

बस सभी 00द्वारा प्रतिस्थापित करें 0।

— क्रिस्टोफ
स्रोत

4

ऐलिस , 13 बाइट्स

/oe00/
@iS0e\

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

व्याख्या

/.../
@...\

यह रैखिक कार्यक्रमों के लिए एक सरल टेम्पलेट है जो पूरी तरह से साधारण मोड में काम करते हैं। प्रारंभिक /आईपी को दक्षिण पूर्व में जाने के लिए प्रतिबिंबित करता है और फिर यह कोड के माध्यम से तिरछे ऊपर और नीचे उछलता है जब तक कि अंत में दर्पण नहीं होते हैं। वे बस एक एक करके स्थिति को ऑफसेट करते हैं ताकि रास्ते में आईपी शेष कोशिकाओं का पता लगा सके। इस ज़िगज़ैग फैशन में कोड पढ़ना यह बन जाता है:

ie00e0So@

यह एक सरल स्ट्रिंग प्रतिस्थापन है:

i   Read all input.
e   Push an empty string.
00  Append two zeros to create the string "00".
e   Push an empty string.
0   Append a zero to create the string "0".
S   Substitute all occurrences of "00" in the input with "0".
o   Output the result.   
@   Terminate the program.

वहाँ कुछ अन्य तरीके दो तार, जैसे पुश करने के लिए कर रहे हैं '00'0या e000tहै, लेकिन मैं कुछ भी है कि धड़कता 5 वहाँ बाइट्स नहीं मिला है (और मैं दो बाइट्स बंद दाढ़ी होगा कार्यक्रम छोटा करने के लिए सक्षम होने के लिए)।

— मार्टिन एंडर
स्रोत

2

लगता है कि आपको हाल ही में ऐलिस से प्यार हो गया ...

— लीक नून

6

@LeakyNun कृपया मेरी पत्नी को न बताएं ...

— मार्टिन

@MartinEnder मैं श्रीमती एंडर को बताने जा रही हूँ!

— एरिक आउटगॉल्फ

3

प्रोलॉग (एसडब्ल्यूआई) , 42 बाइट्स

[0,0|T]*[0|R]:-T*R.
[H|T]*[H|R]:-T*R.
H*H.

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

— Emigna
स्रोत

एक प्रोलॉग उत्तर, लेकिन वह नहीं जिसकी मुझे उम्मीद थी ...

— लीक नून

*ऑपरेटर का उपयोग करने के लिए अच्छी चाल ।

— लीक नून

3

जावा , 131 123 बाइट्स

int[]f(int[]a){int c=0,i=0,l=a.length;for(int x:a)c+=1-x;int[]r=new int[l-c/2];for(c=0;c<l;c+=2-a[c])r[i++]=a[c];return r;}

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

— लीक नन
स्रोत

3

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

इनपुट को एक स्ट्रिंग के रूप में लेता है और एक स्ट्रिंग लौटाता है।

s=>s.replace(/00/g,0)

कोशिश करो

f=
s=>s.replace(/00/g,0)
i.addEventListener("input",_=>o.innerText=f(i.value))
console.log(f("1001001")) // "10101"
console.log(f("110011001")) // "1101101"
console.log(f("11001110011")) // "110111011"
console.log(f("111")) // "111"
console.log(f("001")) // "01"
console.log(f("00")) // "0"
console.log(f("11100001111001001100111100100")) // "1110011110101101111010"

<input id=i><pre id=o>

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

— झबरा
स्रोत

3

लुआ, 33 बाइट्स

print((io.read():gsub("00","0")))

इनपुट के माध्यम से एक स्ट्रिंग लेता है और डबल शून्य को संघनित करता है। आसान।

— गप्पी
स्रोत

3

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

ṣ1j1,1m2

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

संभवतः .replace()या इस तरह के बिना भाषाओं में अन्य उत्तर इस चाल का उपयोग कर सकते हैं।

व्याख्या

ṣ1j1,1m2 - (duplicates the 1s, then halves all lengths)
ṣ1       - split by the element 1
  j1,1   - join the elements with the two-element list 1,1
      m2 - get every second element

— fireflame241
स्रोत

3

ऐलिस , 12 10 बाइट्स

मार्टिन बायर की बदौलत 2 बाइट बच गईं

i.h%.7%$io

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

व्याख्या

यह कार्डिनल मोड में संचालित 1-डी कोड है, इसलिए इसके प्रवाह का पालन करना आसान है:

i                   Read a byte from input (pushes -1 on EOF)
 .h                 Duplicate it and add 1 to the copy
   %                Compute n%(n+1). This will exit with an error on n==-1
                    and return n for any non-negative n.
    .7%             Duplicate the input again and compute its value modulo 7
                    This returns 6 for '0' (unicode value 48) and 0 for '1'
                    (unicode value 49)
       $i           If this last result was not 0, input another number.
                    This ignores every other '0' in the input
                    and moves to the following number (another '0')
         o          Output the last byte read

                    At the end, wrap back to the beginning of the line

— सिंह
स्रोत

आप वास्तव में दो और बाइट्स बचा सकते हैंi.h%...

— मार्टिन एंडर

@MartinEnder आप एक दुष्ट व्यक्ति हैं, लोगों को गंदे खेलने के लिए सिखाने के लिए जा रहे हैं ...: D

— सिंह

2

पायथन (सूची I / O), 36 बाइट्स

f=lambda l:l and l[:1]+f(l[2-l[0]:])

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

पहले तत्व को फिर से लेता है, फिर शेष को हटाता है यदि पहला शून्य था।

38 बाइट्स:

lambda l:eval(`l`.replace('0, 0','0'))

इसे ऑनलाइन आज़माएं यह पायथन सूची लेता है और इसके स्ट्रिंग प्रतिनिधित्व पर प्रतिस्थापन करके पायथन सूची को आउटपुट करता है। स्ट्रिंग I / O एक अधिक प्रत्यक्ष और छोटे समाधान की अनुमति देगा, जैसे कि

lambda s:s.replace('00','0')

के लिए '1001' प्रारूप।

— XNOR
स्रोत

निर्दिष्ट प्रारूप के साथ पहला उत्तर, अच्छा।

— लीक नून

1

स्ट्रिंग I / O की अनुमति है। lambda s:s.replace('00','0')ठीक होना चाहिए।

— जोनाथन एलन

2

एपीएल (डायलॉग) , 9 बाइट्स

'00'⎕R'0'

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

— एडम
स्रोत

2

पर्ल 5, 7 + 1 (-पी झंडा) = 8 बाइट्स

<>if/0/

इनपुट को न्यूलाइन से अलग किए गए नंबरों के रूप में लेता है। यदि यह शून्य देखता है तो अगली पंक्ति को छोड़ देता है।

— क्रिस
स्रोत

2

वी , 4 बाइट्स

òf0x

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

ò    ' Recursively (until we error)
 f0  ' Go to the next zero (errors when there are no zeros left)
   x ' Delete it

— nmjcman101
स्रोत

2

MATL , 5 बाइट्स

FFOZt

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

व्याख्या

यह स्टीवी ग्रिफिन के ऑक्टेव उत्तर के समान है :

FF     % Push [0 0]
O      % Push 0
Zt     % Implicitly take input. Replace [0 0] by 0. Implicitly display

8 बाइट्स

vy~f2L)(

यह स्ट्रिंग / सरणी प्रतिस्थापन बिलिन से बचा जाता है।

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

व्याख्या

[1,0,0,1,0,0,1]उदाहरण के रूप में इनपुट पर विचार करें :

v      % Concatenate stack (which is empty): pushes []
       % STACK: []
y      % Implicit input. Duplicate from below
       % STACK: [1,0,0,1,0,0,1], [], [1,0,0,1,0,0,1]
~f     % Negate, find: gives indices of zeros
       % STACK: [1,0,0,1,0,0,1], [], [2,3,5,6]
2L     % Push [2,2,1i]. As an index, this is interpreted as 2:2:end
       % STACK: [1,0,0,1,0,0,1], [], [2,3,5,6], [2,2,1i]
)      % Reference indexing. This selects the even-indexed entries
       % STACK: [1,0,0,1,0,0,1], [], [3,6]
(      % Assignment indexing. This deletes the specified entries
       % (assigns them the empty array). Implicitly display
       % STACK: [1,0,1,0,1]

— लुइस मेंडो
स्रोत

1

ब्रेकीलॉग , 10 बाइट्स

ḅ{cẹ|ḍh}ᵐc

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

यकीन नहीं है कि यह अभी तक इष्टतम है ...

व्याख्या

यह बग का शोषण करता है जो कि cपूर्णांक वाले शून्य की सूची में विफल हो जाएगा।

ḅ               Blocks; group consecutive equal elements together
 {     }ᵐ       Map on each block:
  c               It is possible to concatenate the block into an int (i.e. it contains 1s)
   ẹ              Split it again into a list of 1s
    |             Else
     ḍh           Dichotomize and take the head
         c      Concatenate the blocks into a single list

— Fatalize
स्रोत

वह बग कैसे है?

— लीक नून

@LeakyNun हम श्रेणीबद्ध में सक्षम होना चाहिए [0,0,4,2]में 42। अग्रणी शून्य इसे अभी विफल बनाते हैं क्योंकि इनपुट के परिवर्तनशील होने पर अनंत अग्रणी शून्य को रोकने के लिए यह यहाँ है, लेकिन यहाँ इनपुट पूरी तरह से ग्राउंडेड है ताकि सीमा मौजूद न हो।

— घातक

क्या आप प्रोलॉग उत्तर लिखेंगे?

— लीक नून

1

सी #, 191 बाइट्स

string a(string s){var l=(s+'1').ToCharArray();s="";int b=0;for(int i=0;i<l.Length;i++){if(l[i]=='1'){if(b>0){s+=new string('0',b/2);b=0;}s+=l[i];}else b++;}return s.Substring(0,s.Length-1);}

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

यह न तो साफ है और न ही छोटा है, लेकिन यह काम करता है।

वर्णों के एक सन्निहित स्ट्रिंग के रूप में इनपुट लेता है, एक ही प्रारूप में आउटपुट करता है

स्पष्टीकरण:

string a(string s){                  //Define method a that takes input string s and returns a string
  var l=(s+'1').ToCharArray();       //Add a 1 to the end of s and split into char array l
  s="";                              //Empty s
  int b=0;                           //Initialize int b with value 0
  for(int i=0;i<l.Length;i++){       //Loop through l
    if(l[i]=='1'){                   //If current char is 1
      if(b>0){                       //If b is not 0
        s+=new string('0',b/2);      //Add half the amount of 0s we've counted to s
        b=0;                         //Reset b
      }                              //End if b is not 0
      s+=l[i];                       //Add current char to s
    }                                //End if current char is 1
    else b++;                        //If current char is not 1, increment b
  }                                  //End loop
  return s.Substring(0,s.Length-1);  //Return string minus last char
}                                    //End method

ध्यान दें

हाँ, मुझे पता है कि यह केवल उपयोग किया जा सकता है s.Replace("00","0"), मेरा उद्देश्य स्पष्ट समाधान का उपयोग करने से बचना था। आखिरकार, PPCG की पूरी बात मज़ेदार है, है ना? ;)

— Skidsdev
स्रोत

@ Mr.Xcoder यह सच नहीं है। यह भाषा के बिल्ट-इन का उपयोग किए बिना प्राप्त किया जा सकता है, क्योंकि Replace मैं C # का उपयोग कर रहा हूं, इसलिए मैं कम से कम संभव कोड प्राप्त करने के बारे में भ्रम में नहीं हूं, विशेष रूप से जेली जैसी भाषाओं के साथ, इसलिए हो सकता है कि आपको थोड़ा मज़ा आए कार्रवाई में।

— स्काइडदेव

बेशक मज़ा भी महत्वपूर्ण है। मैं उपरोक्त टिप्पणी के लिए माफी माँगता हूँ और मुझे यह स्वीकार करना चाहिए कि मुझे आपका उत्तर स्वयं (आपके द्वारा उपयोग की जाने वाली तकनीक) पसंद आया।

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

@ Mr.Xcoder कोई कठिन भावना नहीं है, अंततः हम सभी मज़े करने के लिए यहाँ हैं और जितना संभव हो सके कोड को संपीड़ित करने की हमारी बेकार क्षमता को फ्लेक्स करते हैं;)

— स्काइड्सडेव

आप इस जगह की तुलना में बहुत कम कर सकते हैं ! string a(string s){var r="";for(int i=0;i<s.Length;i+=50-s[i])r+=s[i];return r;} (ऐसा लगता है कि यह मूल रूप से सी उत्तर है)

— विजुअलमेल

1

पायथ, 8 बाइट्स

:z"00"\0

कोशिश-यह लिंक।

स्पष्टीकरण:

:z"00"\0 Takes unquoted contiguous 1-line input.
 z       Initialized to unevaluated first input line (Q won't be any shorter)
  "00"   Matching regex pattern /00/g
      \0 Substitution string "0"
:        Regex find-and-replace

— आउटग्रॉफर को एरिक करें
स्रोत

1

Awk - 18 बाइट्स

पहले अक्क के साथ कुछ भी करने की कोशिश करें ताकि इसे और अधिक गोल्फ करना संभव हो सके।

{gsub(00,0);print}

उपयोग: echo "1001001" | awk '{gsub(00,0);print}'

— PsHegger
स्रोत

1

बैच, 24 बाइट्स

@set/ps=
@echo %s:00=0%

STDIN पर इनपुट लेता है। एक बार के लिए थोड़ा प्रतिस्पर्धी।

— नील
स्रोत

1

आम लिस्प, SBCL, 48 32 बाइट्स

-16 बाइट्स जुलियन वुल्फ के लिए धन्यवाद

(format t"~{~[0~*~;1~]~}"(read))

इनपुट:

(1 0 0 0 0 1 1 1 0 0)

उत्पादन:

व्याख्या

हम इनपुट सूची पढ़ते हैं। सूची का उपयोग formatफ़ंक्शन में किया जाता है । हम इसके माध्यम से लूप करते हैं 1यदि तत्व है 1और इसके 0लिए सूची के अगले तत्व को आउटपुट और स्किप करना है 0।

~[इसके बजाय का उपयोग करने से ~:[आप 0 और 1 के साथ सीधे अनुक्रमण कर सकते हैं, जिससे आपको बाइट्स का एक गुच्छा बचाना चाहिए

— जूलियन वुल्फ

@JulianWolf धन्यवाद!

1

गणितज्ञ, 24 बाइट्स

StringReplace["00"->"0"]

एक फ़ंक्शन जो "0"एस और "1"एस के एक स्ट्रिंग की उम्मीद करता है और एक समान स्ट्रिंग लौटाता है। स्व-व्याख्यात्मक वाक्यविन्यास। मैथेमेटिका में बहुत सारे परिवर्तन निर्मित भवन हैं; कुंजी का उपयोग एक ऐसा है जो प्रत्येक प्रासंगिक उपसंचाई (विपरीत /.) को बदल देता है, लेकिन केवल एक बार अभिव्यक्ति के माध्यम से गुजरता है (विपरीत //.)।

— ग्रेग मार्टिन
स्रोत

1

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

Œg¹m2$S?€F

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

व्याख्या

Œg¹m2$S?€F
Œg          - Group runs of equal elements
        €   - To each run...
      S?    - If sum is truthy,
  ¹         -   return the run as it is
   m2$      - Else return every second element of the run.

— fireflame241
स्रोत

जालसाजों को छुड़ाओ

कार्य

इनपुट

उत्पादन

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

स्कोरिंग

रेटिना , 4 बाइट्स

05AB1E , 5 बाइट्स

हास्केल , 33 बाइट्स

सी (जीसीसी) , 35 बाइट्स

sed , 8 बाइट्स

ऑक्टेव, 22 बाइट्स

जावा, 50 बाइट्स

हास्केल , 28 बाइट्स

जाप , 7 6 5 बाइट्स

पीएचपी, २६

ऐलिस , 13 बाइट्स

व्याख्या

प्रोलॉग (एसडब्ल्यूआई) , 42 बाइट्स

जावा , 131 123 बाइट्स

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

कोशिश करो

लुआ, 33 बाइट्स

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

ऐलिस , 12 10 बाइट्स

व्याख्या

पायथन (सूची I / O), 36 बाइट्स

एपीएल (डायलॉग) , 9 बाइट्स

पर्ल 5, 7 + 1 (-पी झंडा) = 8 बाइट्स

वी , 4 बाइट्स

MATL , 5 बाइट्स

व्याख्या

8 बाइट्स

व्याख्या

ब्रेकीलॉग , 10 बाइट्स

व्याख्या

सी #, 191 बाइट्स

ध्यान दें

पायथ, 8 बाइट्स

Awk - 18 बाइट्स

बैच, 24 बाइट्स

आम लिस्प, SBCL, 48 32 बाइट्स

व्याख्या

गणितज्ञ, 24 बाइट्स

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