कार्य

सकारात्मक पूर्णांक की एक सरणी को देखते हुए, प्रत्येक तत्व को अन्य तत्वों की राशि की समता के साथ बदलें। सरणी में कम से कम 2 तत्व होने की गारंटी है ।

परिभाषा

समता: चाहे संख्या विषम हो या सम।

उदाहरण

सरणी के लिए [1,2,3,1]:

1की समता से प्रतिस्थापित करें 2+3+1, अर्थात even।
2की समता से प्रतिस्थापित करें 1+3+1, अर्थात odd।
3की समता से प्रतिस्थापित करें 1+2+1, अर्थात even।
1की समता से प्रतिस्थापित करें 1+2+3, अर्थात even।

आउटपुट: [even, odd, even, even]

इनपुट

सकारात्मक पूर्णांक की एक सरणी।

आप इसे एक उचित सरणी के रूप में, या सकारात्मक पूर्णांक के लाइनफीड-पृथक स्ट्रिंग के रूप में ले सकते हैं।

आप मान सकते हैं कि सरणी और अंदर के मान आपकी भाषा की हैंडलिंग क्षमता के भीतर हैं।

उत्पादन

दो सुसंगत मूल्यों की एक सरणी , एक का प्रतिनिधित्व करना odd, एक का प्रतिनिधित्व करना even।

आप इसे दो मानों की लाइन-अलग-अलग स्ट्रिंग के रूप में आउटपुट कर सकते हैं।

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

इनपुट:

[1, 2, 3, 1]
[1, 2, 3, 2, 1]
[2, 2]
[100, 1001]

आउटपुट:

[even, odd, even, even]
[even, odd, even, odd, even]
[even, even]
[odd, even]

नोट: आप इसके अलावा oddऔर अन्य संगत मूल्यों का चयन कर सकते हैं even।

स्कोरिंग

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

स्टैंडर्ड लूपोल लागू होता है।

code-golf array-manipulation

— लीक नन
स्रोत

16

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

+SḂ

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

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

+SḂ  Main link. Argument: A (array)

 S   Compute the sum of A.
+    Add the sum to each element of A.
     Using _ (subtraction) or ^ (bitwise XOR) would also work.
  Ḃ  Bit; compute the parity of each resulting integer.

— डेनिस
स्रोत

यह एक चतुर दृष्टिकोण है।

— लीक नून

1

@LeakyNun यह वही तरीका है जो हर कोई उपयोग कर रहा है, केवल कम: P

— ETHproductions

@ETHproductions बहुत, हाँ। थॉट केवल इतने सारे तरीके हैं समता की गणना करने के लिए ...

— डेनिस

@ETHproductions घटाव के बजाय इसके अतिरिक्त का उपयोग करता है ...

— लीक नून

@LeakyNun सच है, मेरे जाप उत्तर के रूप में अच्छी तरह से करता है। जेली में यह सिर्फ होगा_SḂ

— ETHproductions

8

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

a=>a.map(b=>eval(a.join`+`)-b&1)

0सम और 1विषम के लिए उपयोग करता है ।

परीक्षा

f=
a=>a.map(b=>eval(a.join`+`)-b&1)
console.log(f([1, 2, 3, 1]))
console.log(f([1, 2, 3, 2, 1]))
console.log(f([100, 1001]))

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

— ल्यूक
स्रोत

2 बाइट्स: c-b&1इसके बजाय(c-b)%2

— लीकी नून

बाह! आपने मुझे इसमें हरा दिया!

— झबरा

1

मैं उपयोग करने के लिए याद रखना होगा eval(a.join`+`)खत्म हो गया a.reduce((x,y)=>x+y)। यह चतुर है

— साइओस

8

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

f x=odd.(sum x-)<$>x

Trueविषम मूल्यों के लिए और Falseयहां तक कि मूल्यों के लिए उपयोग करता है ।

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

सूची के योग से प्रत्येक तत्व को घटाएं और यदि यह विषम है तो परीक्षण करें।

fpointfree की ओर मुड़ भी 20 बाइट है: map=<<(odd.).(-).sum।

— nimi
स्रोत

6

MATL , 5 , 4 बाइट्स

ts-o

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

एक बाइट ने डेनिस को धन्यवाद दिया!

यह विषम के लिए '1' और सम के लिए '0' देता है। स्पष्टीकरण:

t       % Duplicate the input
 s      % Get the sum of the input
  -     % Subtract it from the original input
   o    % Get the parity of each element

— DJMcMayhem
स्रोत

6

ऐलिस , 31 28 बाइट्स

/O.HQ\d$K@
\i#\ /d2-&+!w?+2%

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

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

लेआउट शायद अभी भी इष्टतम नहीं है, लेकिन मुझे अभी तक इसे छोटा करने का कोई तरीका नहीं मिला है।

व्याख्या

/     Reflect to SE. Switch to Ordinal.
i     Read all input as a string.
      Reflect off bottom boundary. Move to NE.
.     Duplicate the input string.
      Reflect off top boundary. Move to SE.
\     Reflect to N. Switch to Cardinal.
H     Implicitly convert the top copy of the input to the integers it
      contains and take the absolute value of the top-most one. (Taking
      the absolute value doesn't do anything, but we need the implicit
      conversion to integers.)
      The IP wraps back to the second line.
\     Reflect to SE. Switch to Ordinal.
      Immediately reflect off bottom boundary. Move to NE.
Q     Reverse the stack (this converts the integers back to strings but
      that's irrelevant). After this, we end up with all the individual
      integers on the bottom of the stack in reverse order and the other
      copy of the input string with all integers on top.
      Reflect off top boundary. Move to SE.
/     Reflect to E. Switch to Cardinal.
d     Push the stack depth, which is one more than the number of list
      elements (due to the other input string on the stack).
2-    Subtract 2.
&+    Run + that many times, which implicitly converts the second string
      to the integers it contains and then adds up all the list elements.
!     Store the sum on the tape.
w     Push the current IP position to the return address stack. This
      lets us return here repeatedly to implement a loop.

  ?+    Retrieve the input sum from the tape and add it to the current
        element.
  2%    Compute its parity. Other ways to do this are 1A and 0x. 2F would
        also work but it gives 0/2 instead of 0/1.
        The IP wraps the first column of the grid.
  \     Reflect to NE. Switch to Ordinal. The IP bounces diaginally up
        and down until it hits the next \.
  O     Implicitly convert the current parity to a string and print it
        with a trailing linefeed.
  #     Skip the next command (the H).
  \     Reflect to E. Switch to Cardinal.
  d     Push the stack depth. This is zero when we're done.
  $     Skip the next command if the stack depth is indeed zero, which
        exits the loop.

K     Jump to the return address on top of the return address stack without
      popping it (so that the next K will jump there again).

@     Terminate the program.

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

6

पायथ, 7 6 बाइट्स

mi2-sQ

-1 बाइट @KZhang को धन्यवाद

आउटपुट 1 के लिए विषम, 2 के लिए भी।

कोशिश करो!

व्याख्या

m%-sQd2
m      Q    # For each element in the (implicit) input list
   sQ       # Take the sum of all the elements
  -  d      # subtract that element, so that we now have the sum of the other elements
 %    2     # modulo 2; 1=off, 0=even

— KarlKastor
स्रोत

मोडुलो %_2को जीसीडी में बदलकर i2_, आप एक बाइट को बचाते dहुए कोड को बदलकर भी बना सकते हैं mi2-sQ। आउटपुट विषम के लिए 2 और 1 के लिए बदल दिए जाते हैं।

— के झांग

6

05AB1E (विरासत) , 4 3 बाइट्स

O^È

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

O   # Sum
 ^  # XOR with (implicit) input
  È # Print 1 for even / 0 for odd

— रिले
स्रोत

1 बाइट बंद

— लीके नन

मुझे पता है कि थोड़ी देर हो गई है, लेकिन आप प्रारंभिक को हटा सकते हैं D, क्योंकि इनपुट निहित है।

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

5

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

^{-2 बाइट्स लीक ली नन को धन्यवाद}

lambda x:[sum(x)-z&1for z in x]

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

— छड़ी
स्रोत

2 बाइट्स बंद: sum(x)-z&1इसके बजाय(sum(x)-z)%2

— लीकी नून

3

sum(x,z)%2यह भी काम करेगा

— xnor

4

आर, 21 बाइट्स

(sum(n<-scan())-n)%%2

स्टड से सूची को पढ़ता है और विषम के लिए 0 भी लौटाता है। इनपुट को वेरिएबल के nअंदर कॉल करने के sumबजाय बाहर कॉल करने के बजाय, अर्थातn=scan();(sum(n)-n)%%2

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

— ग्यूसेप
स्रोत

3

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

#+Tr@#&/*OddQ

या

OddQ[#+Tr@#]&

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

3

क्लोजर, 30 बाइट्स

#(for[i %](odd?(apply - i %)))

बदले में प्रत्येक मान से सभी मानों को अलग करता है, उदाहरण के लिए इनपुट [a b c d]के साथ दूसरा गणना मूल्य b - a - b - c - d= है -(a + c + d)। आउटपुट falseसम और trueविषम के लिए है।

लेकिन आप +प्रत्येक बाद के कार्यकाल का उपयोग और गणना कर सकते हैं ताकि यह समता को प्रभावित न करे।

— NikoNyrh
स्रोत

3

सीजाम , 10 बाइट्स

{_:+f+1f&}

यह एक अनाम ब्लॉक (फ़ंक्शन) है जो स्टैक से इनपुट लेता है और इसे आउटपुट द्वारा प्रतिस्थापित करता है।

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

व्याख्या

इनपुट पर विचार करें [1 2 3 1]।

{         e# Begin block
          e#   STACK: [1 2 3 1]
  _       e#   Duplicate
          e#   STACK: [1 2 3 1], [1 2 3 1]
  :+      e#   Fold addition over the array: compute its sum
          e#   STACK: [1 2 3 1], 7 
  f+      e#   Map addition over the array with extra parameter
          e#   STACK: [8 10 11 8]
  1       e#   Push 1
          e#   STACK: [8 10 11 8], 1
  f&      e#   Map bit-wise "and" over the array with extra parameter
          e#   STACK: [0 0 1 0]
}         e# End block

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

3

जे , 6 बाइट्स

2|]++/

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

— लीक नन
स्रोत

3

एपीएल (डायलॉग यूनिकोड) , 19 7 बाइट्स

@ Adám को 12 बाइट्स दिए गए

2|+/-¨⊢

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

— क्रिकटी लिथोस
स्रोत

2

जाप , 7 बाइट्स

£x +X&1

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

व्याख्या

 £   x +X&1
 mX{ x +X&1}  // Ungolfed
UmX{Ux +X&1}  // Variable introduction

UmX{       }  // Replace each item in the input array with
         &1   //   the parity of
    Ux        //   the sum of the input array
       +X     //   plus X.
              // Implicit: output result of last expression

— ETHproductions
स्रोत

2

पर्ल 5, 31 बाइट्स

sub{map$x+=$_,@_;map$x-$_&1,@_}

1विषम और 0यहां तक कि के लिए आउटपुट ।

— क्रिस
स्रोत

+1, अच्छा। मुझे लगता है कि यह 28 बाइट्स है, हालांकि: perldoc perlsubकहते हैं, "हस्ताक्षर एक सबरूटीन के शरीर का हिस्सा है। आम तौर पर एक सबरूटीन का शरीर कोड का एक लटके हुए ब्लॉक होता है।"

— msh210

@ msh210 धन्यवाद! मुझे नहीं लगता कि यह कैसे काम करता है, हालांकि- यकीन है कि सबरूटीन का शरीर केवल 28 बाइट्स है, लेकिन आप subइसे तोड़ने के बिना बाहर नहीं निकल सकते ।

— क्रिस

लेकिन कभी-कभी एक सबरूटीन बिना काम करता है sub, उदाहरण के लिए sortया grepकिसी अन्य सबरूटीन के तर्क के रूप में। यह कोड गोल्फ मेटा के बारे में पूछने के लायक हो सकता है ।

— msh210

@ msh210 एक सबरूटीन subकेवल तभी काम करता है जब इसका उपयोग एक प्रोटोटाइप फ़ंक्शन में किया जाता है ( sortऔर grepअधिक या कम प्रोटोटाइप)। लेकिन अन्यथा, subआवश्यक है। भले ही, 3 बाइट्स को छोड़ने subसे गोल्फिंग वास्तव में दिलचस्प नहीं है।

— दादा

2

क्लोजर (स्क्रिप्ट), 36 बाइट्स

आउटपुट trueविषम है और इसके falseलिए भी है। आउटपुट और इनपुट दोनों ही सीक्वेंस हैं।

(fn[l](map #(odd?(-(apply + l)%))l))

— madstap
स्रोत

2

PHP, 50 बाइट्स

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

1 विषम के लिए, 0 के लिए भी

स्ट्रिंग के साथ आउटपुट अलग हो गया _

<?foreach($_GET as$v)echo array_sum($_GET)-$v&1,_;

PHP, 72 बाइट्स

सरणी उपयोग के रूप में आउटपुट array_map

<?print_r(array_map(function($v){return array_sum($_GET)-$v&1;},$_GET));

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

1

आप इसे छोड़ सकते हैं ?:0यह कुछ भी नहीं करता है। foreach($_GET as$v)echo array_sum($_GET)-$v&1,_;

— क्रिस्टोफ़

2

सी, 68 62 बाइट्स

i;s;f(c,l)int*l;{while(i<c)s+=l[i++];while(i)l[--i]=s-l[i]&1;}

1 विषम के लिए, 0 के लिए भी

विस्तृत ऑनलाइन प्रयास करें

f(int c, int * l)
{
    int i = 0, s = 0;

    while(i < c)
    {
        s = s + l[i];
        i = i + 1;
    }

    // assert(i == c)

    while(i > 0)
    {
        i = i - 1;
        l[i] = s - l[i]&1;
    }
}

— Khaled.K
स्रोत

2

रेटिना , 40 38 बाइट्स

\d+
¶$` $'
^¶

\d+
$*
+` |11

%M`1
¶

इसे ऑनलाइन आज़माएं! आउटपुट 1 के लिए विषम और 0 के लिए भी। स्पष्टीकरण: पहली दो लाइनें इनपुट में प्रत्येक संख्या के लिए एक बार इनपुट की नकल करती हैं, लेकिन तत्व के बिना। यह एक अतिरिक्त रिक्त पंक्ति बनाता है जिसे तब हटा दिया जाता है। इनपुट को तब दशमलव से यूनरी में बदल दिया जाता है, रिक्त स्थान हटा दिए जाते हैं और समता की गणना की जाती है। यहां तक कि समता को शून्य में बदल दिया जाता है और परिणाम वापस एक पंक्ति में शामिल हो जाते हैं। संपादित करें: @FryAmTheEggman के लिए 2 बाइट्स सहेजे गए। मैंने कुछ अन्य संस्करणों की कोशिश की, जो वैचारिक रूप से अधिक मनभावन हैं, लेकिन जो व्यक्त करने के लिए बहुत अधिक बाइट लेते हैं:

\d\B

T`2468O`00001
T`d`10`^([^1]*1[^1]*1)*[^1]*1[^1]*$

अपनी समता के लिए सभी आदानों को बदल देता है, फिर कुल समता होने पर अपनी सभी समता को प्रवाहित कर देता है।

\d+
$*
^.*
$&¶$&
 (?=.*$)

11

\B
0
T`d`10`.*¶1
¶0

इनपुट का एक डुप्लिकेट बनाता है, फिर सब कुछ की समता लेता है, फिर समता को निकालता है यदि योग विषम है, तो फिर से योग हटाता है।

— नील
स्रोत

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

— FryAmTheEggman

@FryAmTheEggman आपकी बचत आपके ;एस को वापस रिक्त स्थान में परिवर्तित करने के कम दृश्य तरीके से होती है । यदि आप ;शुरुआत में डालते हैं तो आप एक बाइट को तुरंत हटाने के बजाए सहेज सकते हैं इसके बाद इसे 0. में परिवर्तित कर देता है

— नील

वास्तव में, फिर से देखना, आपका अंतिम चरण सिर्फ रिक्त स्थान के साथ नई सुर्खियों की जगह क्यों नहीं है? कि 2 बाइट नहीं बचा सकते हैं?

— FryAmTheEggman

@FryAmTheEggman हाँ; मुझे लगता है कि मैं मूल रूप से पिछले पुनरावृत्ति में बनाने के लिए एक से अधिक प्रतिस्थापन था।

— नील

2

ओम , 4 बाइट्स

DΣ-é

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

मूल रूप से MATL और 05AB1E उत्तरों का सीधा पोर्ट है। trueसम और falseविषम के लिए उपयोग करता है ।

— निक क्लिफोर्ड
स्रोत

1

k, 9 बाइट्स

{2!x-+/x}

आउटपुट एक के 1लिए है odd, और एक के 0लिए भी है। इसे ऑनलाइन आज़माएं।

Pseudocode में परिवर्तित, यह होगा:

for number in x:
    yield (number - sum(x)) % 2

— zgrep
स्रोत

1

स्काला , 19 बाइट्स

x=>x.map(x.sum-_&1)

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

— ब्रायन मैककिनटन
स्रोत

1

ब्रेन-फ्लैक , 94 68 66 बाइट्स

({({}<>)<>})<>{<>(({})<({}<>{}<>(())){({}[()]<([{}])>)}{}>)<>}<>{}

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

यह कार्य के लिए थोड़ा लंबा लगता है। ऐसा करने के लिए एक अधिक सुविधाजनक तरीका हो सकता है।

व्याख्या

पहले हम स्टैक के योग की गणना करते हैं:

({({}<>)<>})

हम पूरे स्टैक के माध्यम से जाते हैं जो प्रत्येक तत्व को जोड़ते हैं और युग्म को निर्धारित करते हैं

<>{<>(({})<({}<>{}<>(())){({}[()]<([{}])>)}{}>)<>}<>{}

यह एक बहुत अच्छा आधुनिक मोड 2 एल्गोरिथ्म का उपयोग करता है जो मैं इस चुनौती के लिए आया था।

({}(())){({}[()]<([{}]())>)}{}

यह इनपुट घटने के तहत 1 को धक्का देता है जब तक इनपुट शून्य तक नहीं पहुंचता है जब तक कि 1-nहम पहले रखे गए 1 पर प्रदर्शन करते हैं , तब यह इनपुट हटा देता है।

— गेहूं का जादूगर
स्रोत

आप आखिरी में 2 mod कर सकते हैं। आपको योग राशि 2 की आवश्यकता नहीं है।

— लीक नून

@LeakyNun धन्यवाद! मुझे बस यह एहसास हुआ और उन्होंने इसे ठीक किया।

— गेहूं जादूगर

1

समझदार , ५४ ५२ बाइट्स

::^:??[:!^:?^:!^:?^?]|!::^??[!:?^:><^!:?^:!^:?^?]!&|

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

व्याख्या

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

:?^:!^:?^!

यह दुर्भाग्य से कोड के बहुमत का गठन करता है।

पहले हम स्टैक का XOR योग लेते हैं

::^:??[:!^:?^:!^:?^?]|!

हम फिर हर तत्व के साथ XOR करते हैं और इसके साथ वाला तत्व अंतिम रूप से शून्य हो जाता है

::^??[!:?^:><^!:?^:!^:?^?]!&|

— गेहूं का जादूगर
स्रोत

1

जावा , 81 78 बाइट्स

केविन क्रूसेन को 3 बाइट्स धन्यवाद

void f(int[]a){int s=0,i=a.length;for(int x:a)s+=x;for(;i-->0;a[i]=s-a[i]&1);}

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

सरणी में जगह को संशोधित करता है।

— लीक नन
स्रोत

आप इसे 3 बाइट्स में इस तरह से गोल्फ कर सकते हैं:void f(int[]a){int s=0,i=a.length;for(int x:a)s+=x;for(;i-->0;a[i]=s-a[i]&1);}

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

67 बाइट्स यदि आप एक लैम्ब्डा का उपयोग करते हैं: इसे ऑनलाइन आज़माएं!

— ब्रायन मैककचॉन

धन्यवाद, लेकिन मुझे एक लैम्ब्डा का उपयोग करना पसंद नहीं है।

— लीक नून

1

AWK , 64 बाइट्स

{for(i=0;++i<=NF;print s[i]%2)for(j=0;++j<=NF;)if(i!=j)s[i]+=$j}

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

0यहां तक कि सम के लिए आउटपुट और 1न्यूलाइन द्वारा अलग किए गए विषम रकम के लिए। केवल थोड़ा-सा आउट-ऑफ-द-बॉक्स सोच "वेतन वृद्धि" चरण के printअंदर कमांड रख रहा था for। मैंने कुछ "चतुर" तरीके छापने की कोशिश की, लेकिन वे बाइट्स नहीं बचा पाए।

सिर्फ गिगल्स के लिए, यदि आप नई रूपरेखा नहीं चाहते हैं:

{for(i=0;++i<=NF;m=m,s[i]%2)for(j=0;++j<=NF;)if(i!=j)s[i]+=$j}1

जो ऊपर के रूप में एक ही बाइट-गिनती है, लेकिन थोड़ा और अधिक अप्रिय है।

— रॉबर्ट बेन्सन
स्रोत

1

स्विफ्ट - 55 बाइट्स

^{अंत में सी धड़कता है! इसके अलावा, 0 के लिए भी, विषम के लिए 1}

func g(a:[Int]){for i in a{print((a.reduce(0,+)-i)%2)}}

एक फ़ंक्शन, उपयोग के साथ: g(a: [1,2,3,2,1] // => 0 1 0 1 0

इसकी जांच - पड़ताल करें!

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

नहीं स्विफ्ट से परिचित है, लेकिन कई भाषाओं में आप जगह ले सकता है (x-y)%2के साथx-y&1

— Cyoce

@ मेरे लिए, परीक्षण के बाद, यह काम नहीं करता है। बिटवाइज़ ऑपरेशंस स्विफ्ट की

— बाइट

1

Axiom, 45 बाइट्स

f(a)==[(reduce(+,a)-a.j)rem 2 for j in 1..#a]

इनपुट प्रकार के लिए कोई जांच नहीं, योग का संभावित पुनर्गणना "ए" प्रत्येक तत्व ... परीक्षण

(27) -> [[a,f(a)] for a in [[1,2,3,1], [1,2,3,2,1], [2,2], [100, 1001] ]]
   (27)
   [[[1,2,3,1],[0,1,0,0]], [[1,2,3,2,1],[0,1,0,1,0]], [[2,2],[0,0]],
    [[100,1001],[1,0]]]

— RosLuP
स्रोत

1

जूलिया 1.0 , 17 बाइट्स

x->(sum(x).-x).%2

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

— gggg
स्रोत

अन्य तत्वों के योग की समता

कार्य

परिभाषा

उदाहरण

इनपुट

उत्पादन

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

स्कोरिंग

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

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

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

परीक्षा

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

MATL , 5 , 4 बाइट्स

ऐलिस , 31 28 बाइट्स

व्याख्या

पायथ, 7 6 बाइट्स

व्याख्या

05AB1E (विरासत) , 4 3 बाइट्स

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

आर, 21 बाइट्स

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

क्लोजर, 30 बाइट्स

सीजाम , 10 बाइट्स

व्याख्या

जे , 6 बाइट्स

एपीएल (डायलॉग यूनिकोड) , 19 7 बाइट्स

जाप , 7 बाइट्स

व्याख्या

पर्ल 5, 31 बाइट्स

क्लोजर (स्क्रिप्ट), 36 बाइट्स

PHP, 50 बाइट्स

PHP, 72 बाइट्स

सी, 68 62 बाइट्स

रेटिना , 40 38 बाइट्स

ओम , 4 बाइट्स

k, 9 बाइट्स

स्काला , 19 बाइट्स

ब्रेन-फ्लैक , 94 68 66 बाइट्स

व्याख्या

समझदार , ५४ ५२ बाइट्स

व्याख्या

जावा , 81 78 बाइट्स

AWK , 64 बाइट्स

स्विफ्ट - 55 बाइट्स

Axiom, 45 बाइट्स

जूलिया 1.0 , 17 बाइट्स