पृष्ठभूमि

^{"टास्क" पर जाएं यदि आप टिक-टैक-टो से परिचित हैं (मुझे लगता है कि अधिकांश हैं!)}

टिक-टैक-टो एक प्रसिद्ध दो-खिलाड़ी खेल है। इसमें एक 3x3 बोर्ड होता है जो दो खिलाड़ियों द्वारा धीरे-धीरे भरा जाता है (नीचे स्पष्टीकरण); पहला खिलाड़ी चरित्र का उपयोग करता है Xऔर दूसरा उपयोग करता है O। विजेता को लगातार 3 और समान अक्षर ( Xया O) मिलते हैं , जो क्षैतिज, लंबवत या तिरछे होते हैं। यदि बोर्ड भरा हुआ है और कोई भी खिलाड़ी लगातार तीन अक्षर प्राप्त करने में कामयाब नहीं है, तो खेल समाप्त हो जाता है। ध्यान दें कि खेल के अंत में खाली स्थान हो सकते हैं, यदि खिलाड़ियों में से कोई भी कुल 9 चालों से कम में जीतता है (यह टाई के मामले में नहीं हो सकता है)।

कार्य

एक खेल के अंत में टिक-टीएसी-टो बोर्ड को देखते हुए (एक स्ट्रिंग के रूप में, एक मैट्रिक्स, 9 ऑर्डर किए गए मूल्यों की एक फ्लैट सूची, किसी भी अन्य सभ्य प्रारूप), यह निर्धारित करें कि कौन गेम जीतता है।

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

कृपया अपने उत्तर में इन मूल्यों को निर्दिष्ट करें। आप मान सकते हैं कि इनपुट एक मान्य टिक-टैक-टो बोर्ड होगा।

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

X, O, _यहाँ इनपुट मानों कर रहे हैं; X wins, O winsऔर Tieआउटपुट के लिए हैं।

X O X
O X _
O _ X

आउटपुट: X wins।

X _ O
X O _
X O X

आउटपुट: X wins।

X O X
_ O X
_ O _

आउटपुट: O wins।

X O X
O O X
X X O

आउटपुट: Tie।

हमेशा की तरह, हमारे सभी मानक नियम लागू होते हैं। यह कोड-गोल्फ है , हर भाषा में बाइट्स में सबसे छोटा कोड जीतता है!

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

2

मेरे दिमाग से निकल जाओ! शाब्दिक रूप से बस नॉटीज़ एंड क्रॉस के चैलेंज के लिए एक विचार था कि मैं सोमवार को Sanbox वाला था। फिर मैं साइट को खोलता हूँ और यह देखता हूँ!

— शैगी

1

@ शैगी "फास्ट एंड फ्यूरियस" श्रृंखला से किसी को उद्धृत करने के लिए: बहुत धीमी गति से! ; पी

— श्री एक्सकोडर

यह ठीक है, मेरा विचार एक खेलने योग्य संस्करण के लिए था, यह मानते हुए कि यह पहले से ही नहीं किया गया है।

— झबरा

4

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

— आउटगॉल्फ

1

@ जोशुआ यह एक टिक-टैक-टो गेम बनाने के बारे में है। यह ग्रेडिंग के बारे में है।

— डोनीएलएफ

6

जेली , 16 15 14 बाइट्स

U,Z;ŒD$€ẎḄỊÐḟḢ

मूल्यों के साथ सूचियों की एक सूची (पंक्तियों - या स्तंभों) को स्वीकार करने वाला एक विचित्र लिंक:

X = 0.155; O = -0.155; _ = 0

लौटने के परिणाम:

X wins = 1.085; O wins = -1.085; Tie = 0

नोट: के लिए शून्य के मान का उपयोग करना _, और बराबर और विपरीत मूल्यों के लिए Xऔर O, यह मान (यहां 0.155) सीमा में हो सकता है (1/6, 1/7)(दोनों सिरों पर अनन्य) - मैंने केवल उस श्रेणी में एक मान चुना है जो एक सटीक प्रतिनिधित्व योग्य फ्लोटिंग पॉइंट परिणाम देता है जीत के मामलों के लिए।

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

कैसे?

U,Z;ŒD$€ẎḄỊÐḟḢ - Link: list of lists (as described above)
U              - upend (reverse each row)
  Z            - transpose (get the columns)
 ,             - pair the two
      $€       - last two links as a monad for each of them:
    ŒD         -   diagonals (leading diagonals - notes: 1. only one is of length 3;
               -              2. the upend means we get the anti-diagonals too)
        Ẏ      - tighten (make a single list of all the rows, columns and diagonals)
         Ḅ     - from binary (vectorises) (note that [0.155, 0.155, 0.155]
               -                           converts to 4*0.155+2*0.155+1*0.155 = 1.085
               -                           and [-0.155, -0.155, -0.155]
               -                           converts to 4*-0.155+2*-0.155+1*-0.155 = -1.085
               -                           while shorter lists or those of length three
               -                           with any other mixtures of 0.155, -0.155 and 0
               -                           yield results between -1 and 1
               -                           e.g. [.155,.155,0] -> 0.93)
           Ðḟ  - filter discard if:
          Ị    -   insignificant (if abs(z) <= 1) (discards all non-winning results)
             Ḣ - head (yields the first value from the list or zero if it's empty)

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

हां, मुझे लगता है कि किसी भी गूढ़ भाषा के जवाब में स्पष्टीकरण होना चाहिए (और मुझे सामान्य भाषाओं के लिए स्पष्टीकरण भी देखना पसंद है!)

— जोनाथन एलन

इसे जोड़ने के लिए धन्यवाद! बहुत अच्छा दृष्टिकोण, मैं क्या हालांकि की ... अच्छा है और अधिक से अधिक चालाक रास्ता

— श्री Xcoder

6

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

a=>"012+345+678+036+147+258+048+246T".replace(/\d/g,n=>a[n]||!1).match(/(\d)\1\1|T/)[0]

इनपुट

एक्स के रूप में प्रतिनिधित्व किया है 1
हे के रूप में प्रतिनिधित्व किया है 2
_ के रूप में प्रतिनिधित्व किया है 0

उत्पादन

एक्स जीत के रूप में प्रतिनिधित्व किया है "111"
ओ जीत के रूप में प्रतिनिधित्व किया है "000"
टाई के रूप में प्रतिनिधित्व किया है "T"

व्याख्या

a=>
    "012+345+678+036+147+258+048+246" // List of indexes for each row
    .replace(/\d/g,n=>a[n]||!1)       // Replace all digits with the value of the cell
    .match(/(\d)\1\1|$/)[0]           // Find the first row filled with the same value

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

f=
a=>"012+345+678+036+147+258+048+246T".replace(/\d/g,n=>a[n]||!1).match(/(\d)\1\1|T/)[0]
console.log(f([1,2,1,2,1,0,2,0,1]))
console.log(f([1,0,2,1,2,0,1,2,1]))
console.log(f([1,2,1,0,2,1,0,2,0]))
console.log(f([1,2,1,2,2,1,1,1,2]))

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

— हरमन एल
स्रोत

"आपका प्रोग्राम 3 अलग, सुसंगत और गैर-रिक्त मानों को आउटपुट करने में सक्षम होना चाहिए ", इसलिए आप टाई के लिए खाली स्ट्रिंग का उत्पादन नहीं कर सकते।

— RedClover

1

@Soaku मेरा बुरा, मैं नियमों के उस हिस्से को याद किया।

— हरमन एल

4

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

UŒD;;Z;ŒDµSA⁼3µÐfḢ

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

X= 1, O= -1, _= 0
X जीतता है = [1, 1, 1], O जीतता है = [-1, -1, -1], टाई = 0
इनपुट (1, -1, 0)प्रत्येक में 3 तत्वों की 3 सूचियों की सूची के रूप में ।

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

वाह नीस ... जब आप गोल्फिंग कर रहे हैं, तो कृपया I / O मान और एक स्पष्टीकरण जोड़ दें :-)

— श्री Xcoder

यहाँ थोड़ा कम परीक्षण के साथ एक समान दृष्टिकोण है। लेता है X= 1, O= 2, _= 3, रिटर्न 1(एक्स जीत), 2(ओ जीत) या 3(टाई)।

— अर्नुलद

@ छोटा करने के लिए अरनॉल्ड थैंक्स

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

3

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

lambda b:{'XXX','OOO'}&{*b.split(),b[::4],b[1::4],b[2::4],b[::5],b[2::3]}

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

पायथन 2 , 100 95 92 87 82 77 बाइट्स

lambda b:{'XXX','OOO'}&set(b.split()+[b[::4],b[1::4],b[2::4],b[::5],b[2::3]])

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

इनपुट को एक नई लाइन के रूप में अलग स्ट्रिंग में ले जाता है XO_

आउटपुट:

{'XXX'}के लिए X,
{'OOO'} के लिये O
{} एक टाई के लिए

स्ट्रिंग को पंक्तियों के स्तंभों और विकर्णों में काटकर कार्य करता है:

The board:
    1 2 3
    4 5 6
    7 8 9
which is '123\n456\n789' is sliced into:

['123', '456', '789', '147', '258', '369', '159', '357']
rows: b.split() -> ['123', '456', '789']
cols: [b[::4],b[1::4],b[2::4]] -> ['147', '258', '369']
diag: [b[::5],b[2::3]] -> ['159', '357']

तब 'XXX'और 'OOO'स्लाइस के खिलाफ जाँच की जाती है।

इनपुट को एक नई लाइन के रूप में अलग स्ट्रिंग में ले जाता है XO_

आउटपुट:

{'XXX'}के लिए X,
{'OOO'} के लिये O
{} एक टाई के लिए

स्ट्रिंग को पंक्तियों के स्तंभों और विकर्णों में काटकर कार्य करता है:

The board:
    1 2 3
    4 5 6
    7 8 9
which is '123\n456\n789' is sliced into:

['123', '456', '789', '147', '258', '369', '159', '357']
rows: b.split() -> ['123', '456', '789']
cols: [b[::4],b[1::4],b[2::4]] -> ['147', '258', '369']
diag: [b[::5],b[2::3]] -> ['159', '357']

तब 'XXX'और 'OOO'स्लाइस के खिलाफ जाँच की जाती है।

— TFeld
स्रोत

पायथन स्लाइसिंग FTW Anyways, 81 बाइट्स , काम करना चाहिए, मुझे लगता है।

— 9

@icrieverytim [2::2]स्लाइस करता है 3579, जबकि [2:8:2]देता है357

— TFeld

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

— जोनाथन फ्रेच

3

आर, 118 116 115 बाइट्स

@ User2390246 को दो अतिरिक्त बाइट्स के लिए धन्यवाद ।

function(M,b=table,u=unlist(c(apply(M,1,b),apply(M,2,b),b(diag(M)),b(M[2*1:3+1]))))`if`(any(u>2),names(u[u>2]),"T")

थोड़ा अपराजित:

function(M){
    u=unlist(c(apply(M,1,table), #Contingency table of the rows
             apply(M,2,table), #of the columns
             table(diag(M)), #of the diagonal
             table(M[2*1:3+1]))) #of the opposite diagonal
    `if`(any(u>2),names(u[u>2]),"T") #Give name of element that occurs more than twice in any setting
 }

रिटर्न Xअगर एक्स जीत, Oहे जीत अगर और Tएक टाई के मामले में।

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

— plannapus
स्रोत

1

M[c(3,5,7)]इसके विपरीत विकर्ण के लिए छोटा है

— user2390246

3

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

56 बाइट्स कोड + 2 एफपीआर -p0।

$_=eval sprintf'/(.)(.{%s}\1){2}/s||'x4 .'0?$1:T',0,2..4

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

आउटपुट Xऔर Oजीत के लिए, या Tएक टाई के लिए। एक ही बार में सभी का परीक्षण करने के लिए हैडर / पाद कोड का एक गुच्छा शामिल है।

वैकल्पिक, 58 बाइट्स

$}.="/(.)(.{$_}\\1){2}/s||"for 0,2..4;$_=eval$}.'0?$1:T'

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

— डोम हेस्टिंग्स
स्रोत

2

पायथन 2 , 124 118 117 115 बाइट्स

छः बाइट्स को बचाना धन्यवाद एग्री द आउटगॉल्फ ; अल्पविराम से बचने के लिए एक स्ट्रिंग का उपयोग करना।
श्री एक्सकोडर को एक बाइट धन्यवाद दिया ; गोल्फ [j*3:j*3+3]के लिए [j*3:][:3]।
स्ट्रिंग को संपीड़ित करने के लिए एक जादुई संख्या का उपयोग करके दो बाइट्स सहेजे गए।

def T(B):
 for j in range(8):
	a,b,c=map(int,`0x197bf3c88b2586f4bef6`[j*3:][:3])
	if B[a]==B[b]==B[c]>0:return B[a]

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

इनपुट / आउटपुट मान

X के रूप में प्रतिनिधित्व किया है 1
O के रूप में प्रतिनिधित्व किया है 2
_ के रूप में प्रतिनिधित्व किया है None

— जोनाथन फ्रेच
स्रोत

[8,0,3,6,1,4,7,2,5,8,0,4,8,2,4,6]->map(int,'8036147258048246')

— आउटगॉल्फ

@EriktheOutgolfer धन्यवाद मैं पूर्णांक सूची का उपयोग करने की कोशिश कर रहा था map(ord,"..."), हालांकि nulएक स्ट्रिंग के बीच में बाइट ने काम नहीं किया ...

— जोनाथन फ्रैच

117 बाइट्स । [j*3:j*3+3]है [j*3:][:3]। एक साइड नोट के j*3+3रूप में -~j*3, के रूप में ही है , लेकिन वह भी 118 बाइट्स है।

— श्री एक्सकोडर

@JonathanFrech आपको एक अतिरिक्त लग रहा है 01234567...

— द एग्जॉस्ट द आउटोलॉफ़र

1

@ Mr.Xcoder धन्यवाद। आज एक नया स्लाइसिंग गोल्फ सीखा।

— जोनाथन फ्रेच

2

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

lambda x:h(x,1)*2or+h(x,0)
h=lambda x,y:g(x,y)or g(zip(*x),y)or x[0][0]==x[1][1]==x[2][2]==y or x[0][2]==x[1][1]==x[2][0]==y
g=lambda x,y:any(all(e==y for e in r)for r in x)

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

के मैट्रिक्स के रूप में इनपुट 1 == X, 0 == O, -1 == _
एकल मान के रूप में आउटपुट: 2 == X, 1 == O, 0 == TIE

-8 बाइट्स एग्री टू द आउटग्राफर

— HyperNeutrino
स्रोत

आप lambda x:h(x,1)*2or+h(x,0)-8 बाइट्स के साथ पहली पंक्ति को बदल सकते हैं और 0 == TIE(जो कि प्रीटीयर इमो है)।

— आउटगॉल्फ

@EriktheOutgolfer शांत, धन्यवाद

— हाइपरएन्यूट्रीनो

2

PHP, 70 बाइट्स

for($c=95024101938;${${$i++&7}.=$argn[$c%9]}=1<$c/=3;);echo$XXX-$OOO;

मान लेता है -n(दुभाषिया चूक)। इसके अतिरिक्त -R( <code>इनपुट की प्रत्येक पंक्ति के लिए निष्पादित) की आवश्यकता होती है , जिसे एक के रूप में गिना जाता है।

इनपुट को एक ही लाइन पर लिया जाता है (बिल्कुल समस्या वर्णन में, सभी व्हाट्सएप को छोड़कर)।

आउटपुट निम्नलिखित है: 1→ X जीत, -1→ O जीत, 0→ टाई।

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

— Primo
स्रोत

आपको पूरे स्ट्रिंग्स की आवश्यकता नहीं है, आप अपने आउटपुट मान चुन सकते हैं। 'X Wins'बदला जा सकता है 'X'(या एक पूर्णांक - भी 1)। एक ही लागू होता है 'O wins'और Tie। कहा जा रहा है, 109 बाइट्स ।

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

@ Mr.Xcoder स्पष्टीकरण के लिए धन्यवाद।

— प्रिमो

1

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

;
;;
.*(\w)(.)*\1(?<-2>.)*(?(2)(?!))\1.*
$1
..+
T

इसे ऑनलाइन आज़माएं! इनपुट को 9 Xएस के 11-वर्ण स्ट्रिंग के रूप में लेता है , Oएस या -एस तीन के तीन समूहों में ;एस द्वारा अलग किया जाता है , हालांकि लिंक में एक हेडर शामिल है जो इस प्रारूप में दिए गए परीक्षण मामलों का अनुवाद करता है। एक संतुलित समूह का उपयोग करके एक विजयी रेखा से मेल खाते हुए काम करता है ताकि यह सुनिश्चित हो सके कि तीन मिलान वाले अक्षर समान हैं। (उपयुक्त दूरी 0 (क्षैतिज रेखा), 4 (रिवर्स विकर्ण), 5 (लंबवत रेखा), या 6 (विकर्ण) हैं; अन्य दूरियाँ ;स्ट्रिंग के बाहर एक हिट या विस्तार करेंगी ।)

— नील
स्रोत

1

जावा 8, 112 108 106 104 90 102 93 बाइट्स

b->b.replaceAll(".*(X|O)(\\1|...\\1...|.{4}\\1.{4}|..\\1..)\\1.*","$1").replaceAll("..+","T")

+12 बाइट्स (90 → 102) दोनों के बजाय केवल एक विकर्ण की जाँच के बग-फिक्स के कारण ..
-9 बाइट्स (102 → 93) के replaceAllबजाय का उपयोग करके matches।

प्रारूप XOX OX_ O_X, आउटपुट X, Oया में इनपुट T।

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

b->{                   // Method with String as both parameter and return-type
  b.replaceAll(".*(X|O)(\\1|...\\1...|.{4}\\1.{4}|..\\1..)\\1.*",
                       //  If we found a line of X or O:
     "$1")             //   Replace it with either X or O
   .replaceAll("..+",  //  If there are now more than 2 characters left:
     "T")              //   Replace it with T
                       // End of method (implicit / single-line return-statement)

स्पष्टीकरण रेगेक्स:

.*(X|O)(\1|...\1...|.{4}\1.{4}|..\1..)\1.*
.*                                      .*# 0 or more trailing & leading chars
  (X|O)                               \1  # X or O next to those leading/trailing chars
       (\1                                # A single X or O in between (row found)
          |...\1...                       # 3 chars, X or O, 3 chars (column found)
                   |.{4}\1.{4}            # 4 chars, X or O, 4 chars (diagonal TL→BR found)
                              |..\1..)    # 2 chars, X or O, 2 chars (diagonal TR→BL found)

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

0

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

.*(X|O)\1\1.*
$1
(X|O).. \1.. \1..
$1
.(X|O). .\1. .\1.
$1
..(X|O) ..\1 ..\1
$1
(X|O).. .\1. ..\1
$1
..(X|O) .\1. \1..
$1
..+
_

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

... मुझे लगता है कि आप इस क्रूर बल को बुला सकते हैं ... सोचा कि इसके लिए कुछ योग्यता हो सकती है ...

— totallyhuman
स्रोत

0

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

.*(X|O)(\1|...\1...|.{4}\1.{4}|..\1..)\1.*
$1
..+
T

मेरे जावा 8 उत्तर का पोर्ट । प्रारूप XOX OX_ O_X, आउटपुट X, Oया में इनपुट T।

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

.*(X|O)(\1|...\1...|.{4}\1.{4}|..\1..)\1.*
.*                                      .*# 0 or more trailing & leading chars
  (X|O)                               \1  # X or O next to those leading/trailing chars
       (\1                                # A single X or O in between (row found)
          |...\1...                       # 3 chars, X or O, 3 chars (column found)
                   |.{4}\1.{4}            # 4 chars, X or O, 4 chars (diagonal TL→BR found)
                              |..\1..)    # 2 chars, X or O, 2 chars (diagonal TR→BL found)

$1                                        #  Replace match of above with either X or O

..+                                       # If there are now 2 or more characters left:
T                                         #  Replace everything with T

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

0

जे, 34 बाइट्स

[:>./[:+./"1(2 1 0},:0 1 2}),(,|:)

Ungolfed:

[: >./ [: +./"1 (2 1 0} ,: 0 1 2}) , (, |:)

व्याख्या

एन्कोडिंग:

X = 2
O = 3
_ = 1

हमारी उच्च-स्तरीय रणनीति पहले एक मैट्रिक्स बनाना है जिसकी पंक्तियों में से प्रत्येक एक संभावित जीत है। पंक्ति एक विकर्ण / है, पंक्ति 2 विकर्ण \ है, अगली तीन पंक्तियाँ पंक्तियाँ हैं, और अंतिम तीन पंक्तियाँ स्तंभ हैं। इस भाग को वाक्यांश (आइटम संशोधन का उपयोग करके }) पूरा किया जाता है :

(2 1 0},:0 1 2}),(,|:)

अंत में हम प्रत्येक पंक्ति का GCD लेते हैं:

+./"1

हमारे एन्कोडिंग के लिए धन्यवाद, रिक्त के साथ किसी भी पंक्ति में 1 का जीसीडी होगा, क्योंकि किसी भी पंक्ति में एक्स और ओएस का कोई भी मिश्रण होता है, क्योंकि 2 और 3 कोप्रेम हैं। तो हम सभी को अगले करने की जरूरत है अधिकतम तत्व मिल रहा है:>./

यदि खेल एक टाई है, तो यह होगा 1. यदि कोई खिलाड़ी जीतता है, तो यह उस खिलाड़ी की संख्या होगी।

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

— जोनाह
स्रोत

0

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

([a,b,c,d,e,f,g,h,i])=>e&(a&i|c&g|b&h|d&f)|a&(b&c|d&g)|i&(c&f|g&h)

इसे सरल रखना।

इनपुट: एक स्ट्रिंग, या संख्याओं या तारों 0का एक रिक्त स्थान, 1एक एक्स, और 2एक ओ के अनुरूप ।
आउटपुट: 0एक टाई के लिए, 1एक्स जीत के लिए, 2ओ जीत के लिए।

विस्तृत, हल्की टिप्पणी:

( [a,b,c,d,e,f,g,h,i] ) => // Break apart the input into nine variables w/ destructuring
  // Run through all possible win conditions. 1&1&1 -> 1, 2&2&2 -> 2
  e & (             // All victories involving the middle square
    a & i | c & g | // Diagonal lines
    b & h | d & f   // Vertical/horizontal through the middle
  ) | 
  a & ( b & c | d & g ) | // Victories with the top-left square
  i & ( c & f | g & h )   // Victories with the bottom-right square

— यार रैंड
स्रोत

टिक-टैक-टो - एक्स या ओ?

पृष्ठभूमि

कार्य

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

जेली , 16 15 14 बाइट्स

कैसे?

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

इनपुट

उत्पादन

व्याख्या

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

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

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

पायथन 2 , 100 95 92 87 82 77 बाइट्स

आर, 118 116 115 बाइट्स

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

वैकल्पिक, 58 बाइट्स

पायथन 2 , 124 118 117 115 बाइट्स

इनपुट / आउटपुट मान

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

PHP, 70 बाइट्स

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

जावा 8, 112 108 106 104 90 102 93 बाइट्स

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

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

जे, 34 बाइट्स

व्याख्या

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