32

कभी-कभी, जब मैं वास्तव में ऊब जाता हूं तो मैं गैर-नकारात्मक पूर्णांक की एक सरणी का योग लेना पसंद करता हूं। मैं केवल लंबाई की सरणियों का योग लेता हूं जो दो की शक्तियां हैं। दुर्भाग्य से मैं अक्सर गलतियाँ करता हूँ। सौभाग्य से मैं अपने काम पर नज़र रखता हूं क्योंकि मैं निम्नलिखित तरीके से जाता हूं:

मैं आसन्न संख्याओं के जोड़े को तब तक जोड़ता हूं जब तक कि केवल एक ही शेष न हो। उदाहरण के लिए:

 6 + 18 + 9 + 6 + 6 + 3 + 8 + 10
=  24   +   15  +   9   +   18
=       39      +       27
=               66

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

इनपुट: एक सरणी / सूची / आदि। यदि आपकी भाषा को इसकी आवश्यकता है तो गैर-नकारात्मक पूर्णांक, और संभवतः उस सरणी की लंबाई भी। यह सरणी सभी संख्याओं को बाएं से दाएं और फिर ऊपर से नीचे पढ़ा जाएगा। उदाहरण के लिए ऊपर का सरणी बन जाएगा:
[[6, 18, 9, 6, 6, 3, 8, 10], [24, 15, 9, 18], [39, 27], [66]]
या
[6, 18, 9, 6, 6, 3, 8, 10, 24, 15, 9, 18, 39, 27, 66]यदि आप चाहें।

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

सही योग के कुछ उदाहरण:

6

5+6
=11

  3 + 2 + 4 + 5
=   5   +   9
=       14

[0, 1, 2, 3, 1, 5, 6]

[[1, 2, 4, 8], [3, 12], [15]]

गलत योग के कुछ उदाहरण:

5+4
=8

4 + 4 + 4 + 4
= 9   +   7
=     16

[[1, 2, 3, 4], [7, 3], [10]]

[3, 4, 5, 6, 7, 8, 9]

ध्यान रखें कि मैं गलतियाँ कर सकता हूँ और फिर भी सही उत्तर पा सकता हूँ। अगर मैं एक गलती करता हूं तो यह कभी भी एक अतिरिक्त संख्या या अंतिम सरणी में एक लापता संख्या का परिणाम नहीं होगा, केवल एक गलत संख्या।

मानक खामियों को मना किया जाता है। प्रत्येक भाषा में सबसे छोटा उत्तर विजेता होता है। एक टाई के मामले में पुराना जवाब जीत जाएगा। मैं तय करने का अधिकार रखता हूं कि "समान भाषा" क्या है, लेकिन मैं कहूंगा कि एक बिंदु को पायथन 2, और पायथन 3 दोनों में अर्जित नहीं किया जा सकता है।

— बिजन
स्रोत

1

साइट पर आपका स्वागत है! अच्छी पहली चुनौती।

— AdmBorkBork

अंतिम तिथि क्यों? चुनौती की तुलना में नई भाषाएँ पहले से ही डिफ़ॉल्ट रूप से निषिद्ध हैं।

— R

मुझे लगता है कि मैं इसे हटा सकता था, विचार यह था कि मुझे कुछ कटऑफ रखने की आवश्यकता है ताकि मैं सही उत्तर के रूप में सेट कर सकता हूं, लेकिन मुझे लगता है कि ऐसा नहीं होना चाहिए।

— बिजन

1

नहीं, आप जो भी आसान हो गोल्फ का उपयोग कर सकते हैं।

— बिजन

उदाहरण [0,1,2,3,1,5,6]अमान्य है क्योंकि "इनपुट: सकारात्मक सरणी के एक सरणी / सूची / आदि।"

— बेन फ्रैंकेल

10

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

Ṗ+2/€ẇ

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

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

Ṗ+2/€ẇ  Main link. Argument: A (2D array)

Ṗ       Pop; yield A without its last element. Let's call the result B.
  2/    Pairwise reduce...
    €     each array in B...
 +          by addition.
     ẇ  Window exists; test if the result appears in A as a contiguous subarray.

— डेनिस
स्रोत

9

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

lambda l:map(sum,zip(*[iter(l)]*2))==l[len(l)/2+1:]

इसे ऑनलाइन आज़माएं! परीक्षण मामलों के लिए रॉड का धन्यवाद।

पूरी सूची को इनपुट के रूप में फ्लैट लेता है। जिप / iter ट्रिक का उपयोग करते हुए आसन्न जोड़े में समूह तत्वों, जोड़े का योग लेता है, और जाँचता है कि क्या परिणाम सूची के दूसरे छमाही के बराबर है।

एक पुनरावर्ती विधि 55 बाइट्स के करीब आई:

f=lambda l:len(l)<2or l[0]+l[1]==l[len(l)/2+1]*f(l[2:])

यह प्रयोग किया जाता है कि इनपुट पूर्णांक सकारात्मक हैं, जो बाद में कल्पना में बदल गया है।

— XNOR
स्रोत

चूंकि प्रश्न की स्थितियां अब गैर-नकारात्मक प्रविष्टियों की अनुमति देती हैं, इसलिए आपका पुनरावर्ती तरीका इसके लिए गलत सकारात्मक संकेत देगा [0,0,1,1,1,1,1]।

— बेन फ्रेंकल

7

रोड़ा , 40 बाइट्स

{[0]if{|x|[[x()|[_+_]]=y]if tryPeek y}_}

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

यह एक अनाम फ़ंक्शन है जो 0अगर कोई गलतियाँ नहीं करता है और यदि गलतियाँ हैं तो कुछ भी नहीं।

स्पष्टीकरण:

{[0]if{|x|[[x()|[_+_]]=y]if tryPeek y}_}
{                                      } /* Anonymous function */
      {|x|                           }_  /* Loop over lists in the stream */
                         if tryPeek y    /* If there are lists left after this */
            x()                          /* Push values in list x to the stream */
               |[_+_]                    /* Sum every pair of numbers in x */
           [         ]                   /* Create a list of sums */
                      =y                 /* If the list equals to the next list */
          [             ]                /* Push the result */
    if                                   /* If all results are TRUE */
 [0]                                     /* Return 0 */
                                         /* Otherwise return nothing */

यहां एक संस्करण है जो छोटा है (35 बाइट्स) लेकिन नियमों के खिलाफ (मुझे लगता है):

{{|x|[[x()|[_+_]]=y]if tryPeek y}_}

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

यह एक गुमनाम समारोह है कि धारा और धक्का से मूल्यों को पढ़ता है TRUEया FALSEप्रत्येक सही लाइन के लिए।

मुझे यकीन नहीं है कि यह (एकाधिक रिटर्न मान) नियमों में स्वीकार किया गया है। यहां मेरा बचाव है: रोड़ा में, ifऔर whileब्लॉक की स्थितियां बूलियन मूल्य नहीं हैं, लेकिन धाराएं हैं। एक "सत्य" धारा या तो खाली है या इसमें केवल TRUEs है, और एक "मिथ्या" धारा में एक या अधिक FALSEs हैं। इस तरह, यह फ़ंक्शन "बूलियन" मान लौटाता है। और ifबिना किसी कम-ऑपरेशन आदि के एक बयान की स्थिति के रूप में इस्तेमाल किया जा सकता है ।

— fergusq
स्रोत

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

— बिजन

2

@ बिजन अन्य भाषाएं हैं जिनका समान निर्माण होता है। MATL में, उदाहरण के लिए, संपूर्ण सरणी गलत है यदि इसमें कोई एकल 0है। मुझे यकीन नहीं है कि रोडा कैसे संभालता है, लेकिन यह अनसुना नहीं है।

— AdmBorkBork

1

@ सत्य की सत्य / असत्य की हमारी परिभाषा इस बात पर निर्भर करती है कि एक ifसशर्त के लिए भाषा क्या करेगी । यदि यह है कि रोडा कैसे काम करता है, तो यह हमारे नियमों का अनुपालन करता है, जब तक कि चुनौती कल्पना स्पष्ट रूप से चूक को खत्म नहीं करती है।

— डेनिस

@ डेनिस ऐसा लगता है कि ओपी ने यह मना किया है: "सभी इनपुट जहां एक गलती की जाती है रिटर्न / प्रिंट एक समान परिणाम और सभी इनपुट जिसमें कोई गलती नहीं होती है / एक समान परिणाम प्रिंट करते हैं।" कार्यक्रम की कम भिन्नता में अनंत संख्या में आउटपुट होते हैं।

— फर्ग्यूसक

@fergusq ओह, ठीक है, मैंने इसे नजरअंदाज कर दिया है।

— डेनिस

5

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

lambda x:reduce(lambda a,b:(b==map(sum,zip(a[::2],a[1::2])))*b,x)

इसे ऑनलाइन आज़माएं!
रिटर्न: कुल योग के रूप में
खाली सूचीFalsy
Truthy

— छड़ी
स्रोत

5

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

Most[Tr/@#~Partition~2&/@#]==Rest@#&

शुद्ध कार्य इनपुट और रिटर्न Trueया के रूप में एक नेस्टेड सूची ले रहा है False। यह फ़ंक्शन Tr/@#~Partition~2&किसी सूची के जोड़ीदार सम्स को लेता है, जिसे बाद /@#में इनपुट सूची के प्रत्येक सबलिस्ट में लागू किया जाता है । परिणामी सूची में पहले, दूसरे, ... सब्लिस्ट को मूल इनपुट में दूसरे, तीसरे, ... सब्लिस्ट के बराबर माना जाता है; Most[...]==Rest@#इस संपत्ति के लिए परीक्षण।

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

4

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

lambda l:all(l[i+1]==map(sum,zip(l[i][::2],l[i][1::2]))for i in range(len(l)-1))

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

अन्य अजगर जवाब के रूप में के रूप में काफी अच्छा नहीं है, लेकिन मैं इसे वैसे भी पोस्ट करने की तरह महसूस किया। यह सिर्फ यह दिखाने के लिए जाता है कि मैं नियमित भाषाओं में गोल्फ में उतना अच्छा क्यों नहीं हूं ।

— DJMcMayhem
स्रोत

3

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

a=>!a.slice(-a.length/2).some((n,i)=>a[i+=i]+a[i+1]-n)

एक चपटा सरणी लेता है।

— नील
स्रोत

3

05AB1E , 15 12 बाइट्स

¬svyQy2ôO}\P

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

व्याख्या

¬             # get the first element from input without popping
 sv      }    # for each element y in input
   yQ         # compare y to the top of the stack 
              # leaves 1 on the stack if equal and otherwise 0
     y2ô      # split y in pieces of 2
        O     # sum each pair in the list
          \   # discard the top of the stack (the left over final element of the list)
           P  # product of stack (all the 1's and/or 0's from the comparisons)

— Emigna
स्रोत

3

हास्केल , 82 79 65 बाइट्स

-14 बाइट्स नेमी को धन्यवाद!

p(x:y:z)=x+y:p z
f x=and.zipWith(==)(drop(length x`div`2+1)x)$p x

अगली पंक्ति में नीचे तत्व के प्रत्येक जोड़े को योग की तुलना करके काम करता है। कुछ बाइट्स शायद से गोल्फ हो सकते हैं f, लेकिन मैं यह पता नहीं लगा सकता कि कहां है।

— जूलियन वुल्फ
स्रोत

आप समारोह में सीधे दो मूल्यों जोड़ सकते हैं p: p(x:y:z)=x+y:p zऔर उसके बाद का उपयोग zipWith(==)करने के बजाय zipऔर की सूची गठबंधन Boolके साथ and: f x=and.zipWith(==)(drop(length x`div`2+1)x)$p x।

— नीमी

2

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

lambda v:any(x+v[i-1]-v[(len(v)+i)//2]for i,x in enumerate(v)if i%2)

मुझे पता है कि पहले से ही दो अन्य अजगर उत्तर हैं ... लेकिन यह अजगर 3 में एक है, इसलिए यह विदेशी है।

यह एक चपटा इनपुट पर काम करता है।

आउटपुट :

False अगर कोई गलती नहीं है,

True अगर कोई गलती है।

— बेन फ्रैंकल
स्रोत

2

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

->x{a=b=0;b&&=x[a/2]==x[a]+x[a-1]while x[-a-=2];b}

सरणी को उलटते हुए, पहले आधे (स्थिति n) के किसी भी तत्व को स्थिति n * 2 और n * 2 + 1 में तत्वों का योग होना चाहिए।

— जीबी
स्रोत

2

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

s₂ᵘ{{ġ₂+ᵐ}ᵈ}ᵐ

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

यह सिर्फ भयानक रूप से लंबा है! यहाँ घोंसले की भविष्यवाणी न करने का कोई तरीका होना चाहिए।

विधेय सफल होता है (मुद्रण true.के लिए एक कार्यक्रम के रूप में) यदि कोई गलती किए गए थे और विफल रहता है (मुद्रण false.के लिए एक कार्यक्रम के रूप में) अन्यथा।

s₂ᵘ              Every length 2 substring of the input
   {       }ᵐ    for every element satisfies the following:
    {ġ₂          the pairs of elements of the input
       +ᵐ        when each pair is summed is the output
         }ᵈ      where the input is the first item and the output is the second.

— असंबंधित स्ट्रिंग
स्रोत

1

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

lambda a:[map(int.__add__,x[::2],x[1::2])for x in a[:-1]]==a[1:]

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

एक अनाम फ़ंक्शन जो सूचियों की एक सूची लेता है (काम करने की एक प्रति पंक्ति), और रिटर्न सही है अगर कोई गलती नहीं हुई और अन्यथा गलत हो।

यह अंतिम प्रविष्टि के बिना इनपुट का उपयोग करके काम करता है a[:-1], यह बनाने के लिए कि पहली प्रविष्टि के बिना इनपुट क्या होना चाहिए और यह जांचना कि इनपुट क्या था ==a[1:]।

यह गठन पूर्णांक प्रकार के अतिरिक्त फ़ंक्शन की मैपिंग द्वारा प्राप्त किया जाता है, int.__add__दो "स्लाइस" द्वारा निकाली गई संख्याओं के जोड़े के ऊपर, 0 वें इंडेक्स पर शुरू होने वाले प्रत्येक स्लाइस में एक स्लाइस, दूसरा स्लाइस x[::2]1 से शुरू होने वाले हर दूसरे आइटम पर होता है। सूचकांक, x[1::2]।

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

1

पिप , 20 19 बाइट्स

$*{{b=$+*Ya<>2}MPa}

यह एक अनाम फ़ंक्शन है जो एक तर्क, सूचियों की सूची (जैसे [[1 2 3 4] [3 7] [10]]) लेता है । सभी परीक्षण मामलों की पुष्टि करें: इसे ऑनलाइन आज़माएं!

व्याख्या

एक पिप फ़ंक्शन में, पहले दो तर्क दिए गए हैं aऔर b।

  {               }  Anonymous function:
   {          }MPa    To each pair of sublists from a, map this helper function:
          a<>2         Group the 1st member of the pair into 2-item sublists
         Y             Yank that value (no-op used to override precedence order)
      $+*              Map (*) the fold ($) on addition (+) operator
    b=                 If the 2nd member of the pair is = to the result, 1; else 0
$*                   Modify the outside function by folding its return value on *
                     (makes a list containing all 1's into 1 and any 0's into 0)

उदाहरण के लिए:

a
[[1 2 3 4] [7 3] [10]]

{...}MP
a:[1 2 3 4] b:[7 3]
a:[7 3]     b:[10]

a<>2
[[1 2] [3 4]]
[[7 3]]

$+*
[3 7]
[10]

b=
0
1

Final result of {...}MPa
[0 1]

$*
0

— DLosc
स्रोत

1

PHP, 96 95 बाइट्स:

बिल्डिंस का उपयोग करना:

function f($a){return!$a[1]||array_pop($a)==array_map(array_sum,array_chunk(end($a),2))&f($a);}
// or
function f($a){return!$a[1]||array_map(array_sum,array_chunk(array_shift($a),2))==$a[0]&f($a);}

पुनरावर्ती कार्य वापस trueया false।

पहले समारोह के लिए ब्रेकडाउन :

function f($a){
    return!$a[1]||      // true if array has no two rows ... or
    array_pop($a)==     // remove last row, true if equal to
    array_map(array_sum,    // 3. sum up every chunk
        array_chunk(        // 2. split to chunks of 2
            end($a)         // 1. new last row
        ,2))
    &f($a);             // and recursion returns true
}

पुराने समाधान (96 बाइट्स प्रत्येक) लूप का उपयोग कर:

function f($a){foreach($a[0]as$k=>$v)$b[$k/2]+=$v;return$b==$a[1]&&!$a[2]|f(array_slice($a,1));}
//or
function f($a,$y=0){foreach($a[$y]as$k=>$v)$b[$k/2]+=$v;return$b==$a[++$y]&&!$a[$y+1]|f($a,$y);}

अंतिम कार्य के लिए ब्रेकडाउन :

function f($a,$y=0){
    foreach($a[$y]as$k=>$v)$b[$k/2]+=$v;    // build $b with correct sums from current row
    return$b==$a[++$y]                      // true if $b equals next row
    &&!$a[$y+1]                             // and (finished
        |f($a,$y);                          //      or recursion returns true)
}

पुनरावृत्त स्निपेट, 81 बाइट्स

for(;$a[1];)if(array_pop($a)!=array_map(array_sum,array_chunk(end($a),2)))die(1);
for(;$a[1];)if(array_map(array_sum,array_chunk(array_shift($a),2))!=$a[0])die(1);
for(;$a[++$y];$b=[]){foreach($a[$y-1]as$k=>$v)$b[$k/2]+=$v;if($a[$y]!=$b)die(1);}

मान सरणी पूर्वनिर्धारित $a; गलत होने पर बाहर निकलता है।

— टाइटस
स्रोत

1

सी, 54 बाइट्स:

f(int*s,int*e){return e-s>1?*s+s[1]-*e||f(s+2,e+1):0;}

Ungolfed:

int f(int*s,int*e) {
    if(e-s>1) {
        return *s+s[1] != *e || f(s+2,e+1);
    } else {
        return 0;
    }
}

के साथ टेस्ट करें

#include <assert.h>
int main() {
    int input1[15] = {6, 18, 9, 6, 6, 3, 8, 10, 24, 15, 9, 18, 39, 27, 66};
    assert(!f(input1, input1+8));

    int input2[7] = {3, 4, 5, 6, 7, 8, 9};
    assert(f(input2, input2+4));
}

जैसा कि आप देखते हैं, f()अमान्य इनपुट्स के लिए सही है और वैध लोगों के लिए गलत (= 0) है।

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

— cmaster
स्रोत

1

आर, 92 77 बाइट्स

अनाम फ़ंक्शन जो इनपुट के रूप में संख्याओं का एक फ्लैट अनुक्रम लेता है। वापसी TRUEया FALSEउपयुक्त के रूप में। वैचारिक रूप से xnor के अजगर उत्तर के समान दृष्टिकोण का उपयोग करता है।

function(x,l=sum(1|x)/2)all(rowSums(cbind(x[1:l*2-1],x[1:l*2]))==tail(x,l-1))

पिछला समाधान, पैकेज rollapplyसे फ़ंक्शन का उपयोग करना zoo, और एक सूची के रूप में इनपुट लेना, जैसे list(c(6, 18, 9, 6, 6, 3, 8, 10), c(24, 15, 9, 18), c(39, 27), c(66)):

function(l,T=1){for(i in 2:length(l))T=T&all(zoo::rollapply(l[[i-1]],2,sum,by=2)==l[[i]]);T}

— rturnbull
स्रोत

1

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

एक चपटा सरणी के रूप में इनपुट लेता है। NaNवैध या 0अमान्य के लिए रिटर्न ।

f=([a,b,...c])=>a+b==c[c.length>>1]?f(c):b-b

परीक्षा

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

f=([a,b,...c])=>a+b==c[c.length>>1]?f(c):b-b

console.log(f([6, 18, 9, 6, 6, 3, 8, 10, 24, 15, 9, 18, 39, 27, 66])) // NaN
console.log(f([0, 1, 2, 3, 1, 5, 6]))                                 // NaN
console.log(f([1, 2, 4, 8, 3, 12, 15]))                               // NaN
console.log(f([1, 2, 3, 4, 7, 3, 10]))                                // 0
console.log(f([3, 4, 5, 6, 7, 8, 9]))                                 // 0

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

— Arnauld
स्रोत

0

PHP, 102 बाइट्स

इस प्रारूप में इनपुट एएलएस उराल पैरामीटर ?0=[1,2,3]&1=[3,3]&2=[6] इस इनपुट का उपयोग करते हैं[[int,int],[int]]

<?$r=[$_GET[0]];for(;count(end($r))>1;)$r[]=array_map(array_sum,array_chunk(end($r),2));echo$r==$_GET;

टूट - फूट

$r=[$_GET[0]]; # Set the first item of the input in the result array 
for(;count(end($r))>1;) # till the last item in the result array has only one int
$r[]=array_map(array_sum,array_chunk(end($r),2));# add the next item to the result array
echo$r==$_GET; # compare the input array with the result array

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

0

जाप, 10 बाइट्स

2-D सरणी के रूप में इनपुट लेता है।

äÏeXò mxÃe

कोशिश करो

äÏeXò mxÃe     :Implicit input of 2-D array
ä              :Reduce each consecutive pair of sub-arrays
 Ï             :By passing them through the following function as X & Y, respectively
  e            :  Test Y for equality with
   Xò          :    Split X on every 2nd element
      m        :    Map
       x       :      Reduce by addition
        Ã      :End function
         e     :All true?

— झबरा
स्रोत

सुपीरियर Passtimes

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

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

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

रोड़ा , 40 बाइट्स

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

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

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

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

05AB1E , 15 12 बाइट्स

हास्केल , 82 79 65 बाइट्स

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

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

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

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

पिप , 20 19 बाइट्स

व्याख्या

PHP, 96 95 बाइट्स:

सी, 54 बाइट्स:

आर, 92 77 बाइट्स

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

परीक्षा

PHP, 102 बाइट्स

टूट - फूट

जाप, 10 बाइट्स