एक साधारण एक:

एक सकारात्मक पूर्णांक लो एन से 1000 की तुलना में कम है, और उत्पादन पूर्णांकों 1 करने के लिए n से पूर्णांकों के साथ interleaved n करने के लिए 1 । आपको संख्याओं को संक्षिप्त करना होगा ताकि वे उन दोनों के बीच किसी भी सीमांकक के बिना दिखाई दें।

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

n = 1
11

n = 4
14233241

n = 26
12622532442352262172081991810171116121513141413151216111710189198207216225234243252261

n = 100
110029939849759669579489399210911190128913881487158616851784188319822081218022792378247725762675277428732972307131703269336834673566366537643863396240614160425943584457455646554754485349525051515052495348544755465645574458435942604161406239633864376536663567346833693270317130722973287427752676257724782379228021812082198318841785168615871488138912901191109299389479569659749839921001

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

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

16

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

f=(n,k=1)=>n?f(n-1,k+1)+n+k:''

कैसे?

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

नीचे निम्नलिखित के लिए पुनरावर्तन का विवरण दिया गया है f(4):

f(4) =                                            // initial call
f(4, 1) =                                         // applying the default value to k
f(3, 2) + 4 + 1 =                                 // recursive call #1
(f(2, 3) + 3 + 2) + 4 + 1 =                       // recursive call #2
((f(1, 4) + 2 + 3) + 3 + 2) + 4 + 1 =             // recursive call #3
(((f(0, 5) + 1 + 4) + 2 + 3) + 3 + 2) + 4 + 1 =   // recursive call #4
((('' + 1 + 4) + 2 + 3) + 3 + 2) + 4 + 1 =        // n = 0 --> end of recursion
'' + 1 + 4 + 2 + 3 + 3 + 2 + 4 + 1 =              // final sum
'14233241'                                        // final result

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

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

f=(n,k=1)=>n?f(n-1,k+1)+n+k:''

console.log(f(1))
console.log(f(4))
console.log(f(26))
console.log(f(100))

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

— Arnauld
स्रोत

10

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

lambda n:''.join(`x+1`+`n-x`for x in range(n))

4 बाइट्स के लिए ओवर्स का धन्यवाद

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

स्पष्टीकरण:

lambda n:''.join(`x+1`+`n-x`for x in range(n))
lambda n:                                      # anonymous lambda taking one parameter n
                 `x+1`+`n-x`                   # `x` is repr(x) which is equivalent to str(x) for integers less than INT_MAX
                            for x in range(n)  # integers x in [0, n)

— मेगो
स्रोत

1

पायथन 3 में दो बाइट्स अधिक:f'{x}{n-~-x}'

— L3viathan

2

@ L3viathan यह 3.6 में एक नई सुविधा है।

— Mego

1

पायथन 3.6 पायथन 3 नहीं है?

— L3viathan

6

lambda n:''.join('x+1'+'n-x'for x in range(n))46 बाइट्स के लिए। ( 'backticks के साथ सूची की समझ में बदलें )

— ovs

6

@ ओह, आप बैकटिक से बच सकते हैं -> `\`x+1\``रेंडर टू`x+1`

— रॉड

8

-5 अर्जन जोहान्सन को धन्यवाद

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

f n=do a<-[1..n];[a,n-a+1]>>=show

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

— bartavelle
स्रोत

3

(1) एक doअभिव्यक्ति >>=प्लस लैम्बडा से छोटी है । (2) हालाँकि, showएस का उपयोग करके जोड़ा जा सकता है >>=show।

— अर्जन जोहान्सन

7

दे घुमा के , 25 बाइट्स

printf %s`seq $1 -1 1|nl`

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

प्रिंट घटते क्रम, संख्या रेखाएं बढ़ती जा रही हैं और प्रिंटफ लाइनें जुड़ती हैं

~~अंतरिक्ष सीमांकित, 20 बाइट्स: seq $ 1 -1 1 | nl | xargs~~

— marcosm
स्रोत

अगर यह स्वीकार्य नहीं है, तो मैं इसे seq $1 -1 1|nl|tr -d ' \n\t'8 बाइट्स के लिए बदल सकता

— हूं

1

20 बाइट सबमिशन अमान्य है। मेरा उत्थान 25 बाइट प्रस्तुत करने के लिए है।

— डिजिटल ट्रामा

जैसा कि डिजिटल ट्रॉमा ने उल्लेख किया है, 20-बाइट समाधान अमान्य है।

— एग्रीकल्चर आउटरीक

time printf %s'seq 1000000 -1 1|nl'; grep name /proc/cpuinfo

real    0m7.985s user    0m6.092s sys     0m0.392s model name      : Intel(R) Pentium(R) D CPU 3.00GHz model name      : Intel(R) Pentium(R) D CPU 3.00GHz

— 17'14

7

आर, 35 बाइट्स

n=scan();cat(rbind(1:n,n:1),sep="")

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

rbind(1:n,n:1)पहली पंक्ति में 1 से n और दूसरी में n से 1 के साथ 2 पंक्ति का मैट्रिक्स बनाता है। catसमारोह इस मैट्रिक्स गिर, प्रत्येक स्तंभ नीचे पढ़ने।

— user2390246
स्रोत

1

ध्यान दें कि यह केवल इंटरैक्टिव मोड में काम करता है, और इसके लिए उपयोगकर्ता को nकमांड लाइन (स्टड के माध्यम से गुजरने के बजाय) में प्रवेश करने की आवश्यकता होती है ।

— छायाकार

@ssdecontrol हां, मुझे लगता है कि आमतौर पर इसकी अनुमति है, लेकिन मैं यहां काफी नया हूं, गलत हो सकता है।

— user2390246

मुझे लगता है कि यह आम तौर पर स्वीकार्य है, लेकिन NB, इसे TIO में ठीक से चलाने के लिए आपको फ़ुट्रर

— Giuseppe

6

05AB1E , 6 5 बाइट्स

नए इंटरलेव का उपयोग करके एक बाइट को सहेजा गया, जैसा कि रेव द्वारा सुझाया गया है

LÂ.ιJ

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

व्याख्या

L        # range [1 ... input]
 Â       # create a reversed copy
  .ι     # interleave the lists
    J    # join

— Emigna
स्रोत

के नाम से कोई उपयोगकर्ता राजस्व का सुझाव दिया LÂ.ιJ।

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

@JonathanFrech: मुझे पता है कि आम सहमति अब यह है कि हम चुनौती की तुलना में नई सुविधाओं का उपयोग कर सकते हैं, लेकिन मैं आमतौर पर पुराने उत्तरों को संपादित करने में संकोच कर रहा हूं क्योंकि एक नया अंतर्निहित चुनौती को बेहतर ढंग से पूरा करता है। सभी में इतने सारे उत्तर हैं कि इस तरह से सुधार किया जा सकता है :)

— Emigna

खैर, मैं केवल संदेशवाहक था; संभव @rev को अपना उत्तर पोस्ट करना चाहिए।

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

@JonathanFrech: मेरा मतलब यह नहीं था कि यह फटकार है। Rev ने इसे सही ढंग से किया जब उसने एडिट का सुझाव दिया, क्योंकि जब भी कोई नया बिल्ट-इन किया जाता है, तब किसी नए पोस्ट के बजाय मौजूदा उत्तर को संपादित करना बेहतर होता है। मुझे वास्तव में पुराने उत्तरों को ठीक करने में बेहतर होना चाहिए, कम से कम जब सुझाव दिए जाते हैं।

— एमिगा

4

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

ri,:)_W%]z

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

व्याख्या

ri   e# Read input and convert to integer N.
,    e# Turn into range [0 1 ... N-1].
:)   e# Increment to get [1 2 ... N].
_W%  e# Duplicate and reverse the copy.
]    e# Wrap both in an array to get [[1 2 ... N] [N ... 2 1]]
z    e# Transpose to get [[1 N] [2 N-1] ... [N-1 2] [N 1]]
     e# This list is printed implicitly at the end of the program,
     e# but without any of the array structure (so it's essentially flattened,
     e# each number is converted to a string and then all the strings
     e# are joined together and printed).

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

4

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

->n{n.times{|x|$><<x+1<<n-x}}

स्पष्टीकरण:

->n{n.times{|x|                # x in range [0..n-1]
               $><<            # output on console
                   x+1<<n-x}}  # x+1, then n-x

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

— जीबी
स्रोत

4

व्हॉट्सएप , 71 बाइट्स

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

व्याख्या

sssn  ; push 0 - seed the stack with 0 (this will be our 1->n counter, a)
sns   ; dup
tntt  ; getnum - read n (stored on the heap)
sns   ; dup
ttt   ; retr - pull n onto the stack (this will be our n->1 counter, b)
nssn  ; label 'loop'
snt   ; swap - bring a to the top
ssstn ; push 1
tsss  ; add - increment a
sns   ; dup
tnst  ; putnum - output a as a number
snt   ; swap - bring b to the top
sns   ; dup
tnst  ; putnum - output b as a number
ssstn ; push 1
tsst  ; sub - decrement b
sns   ; dup
ntstn ; jez 'exit' if b is 0
nsnn  ; jmp 'loop'

स्टैक को सही ढंग से सेट करने के लिए पहले जोड़े के निर्देशों की आवश्यकता होती है, व्हॉट्सएप के इनपुट कमांड ढेर को लिखते हैं इसलिए हमें स्टैक पर b (इनपुट मान) वापस कॉपी करने की आवश्यकता होती है। हम एक = 0 से शुरू करते हैं क्योंकि यह 1 के बजाय 0 घोषित करने के लिए कम है (एक बाइट बचाता है) और हमें केवल सामना करने के लिए वेतन वृद्धि निर्देश को फिर से करने की आवश्यकता है। उसके बाद हम सिर्फ लूप और इन्क्रीमेंट a, आउटपुट a, आउटपुट b, डेक्रिमेंट b, जब तक b 0 तक पहुंचता है (डिक्रिमेंट के बाद चेक किया गया)।

— Ephphatha
स्रोत

यह बहुत अधिक गोल्फ हो सकता है यदि आपने वह सब कुछ पीछे हटा दिया है: पी

— बिल्ली

4

हास्केल, 65 48 47 बाइट्स

1 बाइट लाईकोनी के लिए धन्यवाद बचा:

f n=show=<<(\(l,r)->[l,r])=<<zip[1..][n,n-1..1]

6 बाइट्स ने निम्मी को धन्यवाद दिया:

f n=show=<<(\(l,r)->[l,r])=<<zip[1..n][n,n-1..1]

पिछला उत्तर और स्पष्टीकरण:

f n=concatMap show$concatMap(\(l,r)->[l,r])(zip[1..n][n,n-1..1])

यहां पहले से ही एक बेहतर हास्केल उत्तर है, लेकिन मैं हास्केल और कोड गोल्फ दोनों के लिए नया हूं, इसलिए मैं इसे पोस्ट कर सकता हूं :)

यह फ़ंक्शन सूची [1..n] को अपने रिवर्स के साथ जोड़ देता है, जिसके परिणामस्वरूप ट्यूपल्स की सूची होती है।

[(1,n),(2,n-1),(3,n-2)..(n,1)]

तब यह concatMapइस सूची की सूची में tuples की सूची में एक मेमने का उपयोग करता है ...

[[1,n],[2,n-1],[3,n-2]..[n,1]]

... और इसे संक्षिप्त करता है।

[1,n,2,n-1,3,n-2..n,1]

फिर सूची के लिए एक अंतिम concatMapनक्शे showऔर इसे एक ही स्ट्रिंग में सम्मिलित करता है।

f 26 "12622532442352262172081991810171116121513141413151216111710189198207216225234243252261"

— डैन एम्ब्रोगियो
स्रोत

2

इन्फ़िक्स समारोह =<<में एक ही (सूची इकाई के अंदर) के रूप में है concatMap: f n=show=<<(\(l,r)->[l,r])=<<zip[1..n][n,n-1..1]।

— नीमी

1

1) आपका वर्तमान समाधान केवल 48 बाइट्स है। 2) आप ड्रॉप कर सकते हैं nमें [1..n]: यह ऑनलाइन कोशिश करो!

— लकोनी

1) खतरे से दूर एक त्रुटि ... 2) अच्छा फोन!

— डैन एम्ब्रोगियो

3

अजगर, 7 बाइट्स

jksC_BS

इसे ऑनलाइन आज़माएं: प्रदर्शन

स्पष्टीकरण:

jksC_BSQ   implicit Q (=input number) at the end
      SQ   create the range [1, ..., Q]
    _B     bifurcate by inversion, this gives [[1, ..., Q], [Q, ..., 1]]
  sC       zip and flatten result
jk         join to a string

— Jakube
स्रोत

3

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

@(n)printf("%d",[1:n;n:-1:1])

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

— rahnema1
स्रोत

1

मेरा क्रियान्वयन इतना अधिक था, इतना लंबा! अच्छा! =)

— स्टिव ग्रिफिन

3

पर्ल 6 , 20 बाइट्स

{[~] 1..*Z~($_...1)}

झसे आज़माओ

100000 के इनपुट के साथ यह लगभग 10 सेकंड लेता है, जिसमें आउटपुट को संकलित करना और प्रिंट करना शामिल है।

विस्तारित:

{                # bare block lambda with implicit parameter ｢$_｣

  [~]            # reduce using concatenation operator ｢&infix:«~»｣
                 # (shorter than ｢join '',｣)

    1 .. *       # Range from 1 to infinity

    Z~           # zip using concatenation operator

    ( $_ ... 1 ) # deduced sequence starting at the input
                 # going down to 1
}

की Z~जरूरत है~ , क्योंकि अन्यथा यह सूचियों जो रिक्त स्थान के साथ stringify होगा की एक सूची उत्पन्न करता है।

1 से शुरू होने वाली रेंज को सीमित करने की आवश्यकता नहीं है, क्योंकि Z जब कोई भी इनपुट सूची बाहर निकलती है तो रुक जाती है।
यह दो बाइट्स बचाता है (एक स्थान की आवश्यकता होगी $_)

— ब्रैड गिल्बर्ट b2gills
स्रोत

3

जावा 61 बाइट्स

(int n)->{for(int i=0;i<n;System.out.print(i+1+""+(n-i++)));}

— cheemcheem
स्रोत

2

इसके अलावा, PPCG में आपका स्वागत है! :)

— स्टिव ग्रिफिन

हम अनाम कार्यों की अनुमति देते हैं, इसलिए (int n)->{//for loop}यहां काम करना चाहिए।

— नाथन मेरिल

क्या वो बेहतर है?

— 17'18 को शाम

2

हां! आप अपने System.out.print()लूप के अंतिम स्टेटमेंट में संभावित रूप से डाल सकते हैं , लेकिन यह जटिल हो जाता है क्योंकि आप iदो बार उपयोग कर रहे हैं (और आपको इसे अभिव्यक्ति में बढ़ाना होगा)।

— नाथन मेरिल

मैंने लूप के अंदर प्रिंट डाला और अंतिम संभावित स्थान पर मुझे बढ़ा दिया, फिर यह सुनिश्चित करने के लिए टेस्ट मामलों की जांच की कि यह काम किया है, धन्यवाद @NathanMerrill

— cheemcheem

3

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

RṚĖVV

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

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

RṚĖVV  Main link. Argument: n

R      Range; yield [1, ..., n].
 Ṛ     Reverse; yield [n, ..., 1].
  Ė    Enumerate; yield [[1, n], ..., [n, 1]].
   V   Eval; convert each flat array to a string, interpret it as a Jelly program,
       and yield the output. This concatenates the integers in each pair, yielding
       a flat array of integers
    V  Repeat the previous step, concatenating the intgegers from before.

— डेनिस
स्रोत

3

रोड़ा , 21 19 बाइट्स

{seq 1,_<>seq _1,1}

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

यह एक अनाम फ़ंक्शन है जो स्ट्रीम से इनपुट लेता है।

व्याख्या

{seq 1,_<>seq _1,1}               Anonymous function, takes integer n from the stream
        <>                        Interleave
 seq 1,_                            the range 1 .. n with
          seq _1,1                  the range n .. 1

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

2

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

#(let[a(range 1(+ 1 %))](apply str(interleave a(reverse a))))

वस्तुतः वही किया जाता है जो पूछा जाता है। मेरा मानना है कि यह कम तुच्छ समाधान द्वारा किया जा सकता है।

इसे ऑनलाइन देखें

— cliffroot
स्रोत

2

एसीटो , 25 22 बाइट्स

)&
pX`=
(pl0
id@z
r}Z)

स्पष्टीकरण:

हमने एक पूर्णांक पढ़ा और इसे दो स्टैक पर रखा।

id
r}

एक पर, हम रेंज_अप ( Z), दूसरे रेंज_डाउन ( z) पर कॉल करते हैं , फिर हम बाद में इस स्थान पर लौटने में सक्षम होने के लिए कैच मार्क सेट करते हैं:

  @z
  Z)

हम तब जांचते हैं कि वर्तमान स्टैक खाली है या नहीं और बाहर निकलें:

 X`=
  l0

अन्यथा, हम दोनों स्टैकों से प्रिंट करते हैं और कैच मार्क पर वापस आते हैं:

)&
p
(p

— L3viathan
स्रोत

2

आर, 41 बाइट्स

pryr::f(for(i in 1:x){cat(i);cat(x-i+1)})

pryr::f()एक फ़ंक्शन बनाता है जो एक इनपुट लेता है। 1:xप्रत्येक तत्व के 1:xसाथ-साथ प्रत्येक तत्व पर लूप ओवर और प्रिंट करता है x:1। प्रिंट करने के लिए प्रिंट।

— JAD
स्रोत

+1, अच्छा उपयोगpryr

— छायाकार

@ssdecontrol अपनी बहुत ज्यादा बदली की जगह function(x):)

— JAD

2

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

⟦₁g↔ᶻczcc

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

व्याख्या

⟦₁           [1, …, Input]
  g↔ᶻc       [[1, …, Input],[Input, …, 1]]
      z      Zip
       cc    Concatenate twice

— Fatalize
स्रोत

2

MATL, 13 11 9 बाइट्स

2 बाइट्स @Luis की बदौलत बच गईं

:tPv1eVXz

इस पर प्रयास करें MATL ऑनलाइन आज़माएं

व्याख्या

        % Implicitly grab input as a number, N
:       % Create an array from 1..N
tP      % Create a reversed copy
v       % Vertically concatenate the two
1e      % Reshape it into a row vector
V       % Convert to a string
Xz      % Remove whitespace and implicitly display

— Suever
स्रोत

@LuisMendo आह! मैंने सोचा था कि एक समारोह है जो व्हाट्सएप को हटा दिया गया था लेकिन वह नहीं मिला। धन्यवाद!

— स्वेवर

2

PHP, 36 35 29 बाइट्स

for(;$argn;)echo++$i,$argn--;

जॉग हल्सरमैन को एक बाइट धन्यवाद दिया।
क्रिस्टोफ की बदौलत छह बाइट्स बचाए।

— user63956
स्रोत

3

उम्म… for(;$argn;)echo++$i,$argn--;?

— क्रिस्टोफ़

2

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

यह सबसे अच्छा नहीं है, लेकिन यह मेरा पहला कोड गोल्फ है।

n=>1.to(n).foldLeft("")((s,x)=>s+x+(n-x+1))

— अचंभा
स्रोत

2

वी , 20 बाइट्स

ywo1@"ñykPjñkògJ

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

के बारे में बताएं:

yw                    ' Copy the input number (for looping later)
  o1                 ' Insert a 1 under the input (on a newline)
     @"               ' [Copy register] number of times
       ñ      ñ       ' Do the thing inside of this loop
        ykP           ' Copy the current line and line above it, and paste above both
           j        ' decrement the current (top) number, and increment the one below
               k      ' Go to the top line
                ògJ   ' recursively join all of the lines

— nmjcman101
स्रोत

2

क्यूबिक्स , 17 बाइट्स

....1I>sO)su.@?(O

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

cubified:

    . .
    . .
1 I > s O ) s u
. @ ? ( O . . .
    . .
    . .

पुश 1, इनपुट में पढ़ता है ( I), फिर लूप में प्रवेश करता है जो स्टैक के शीर्ष को स्वैप करता है, इसे आउटपुट करता है, इंक्रीमेंट करता है, स्वैप करता है, स्टैक के शीर्ष को आउटपुट करता है, घटता है, और स्टैक के शीर्ष 0 है, तो रोकता है।

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

2

के (ngn / k) , 16 बाइट्स

{,//$r,'|r:1+!x}

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

— Thaufeki
स्रोत

r,'|r:->+|:\

— ngn

2

मैथॉल्फ , 5 बाइट्स

{îkï-

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

स्पष्टीकरण:

{      Run a for loop over implicit input
 î     Push 1 based index of loop
  k    Push inputted number
   ï-  Subtract 0 based index of loop
       Implicitly output all this joined together

— मजाक कर रहा है
स्रोत

1

मैं लंबाई 5 से 13 कार्यक्रमों के लिए जो समान ही परिणाम प्राप्त करने में सक्षम किया गया है: ╒{ïí,, ╒{ïk,, ╒{íï-, ╒{kï-, ╒{┐í,, ╒{┐k,, ╒x{î\ , {îïí,, {îïk,, {îíï-, {îkï-, {î┐í,, {î┐k,। हालाँकि, मुझे लंबाई 4 या उससे कम के किसी भी कार्यक्रम का पता नहीं चल पाया है। मैंने पूरी खोज नहीं की है, लेकिन यह बहुत संभावित है कि 5 बाइट्स मैथॉल्फ के लिए इष्टतम हों।

— अधिकतम

2

आम लिस्प, 63 54 बाइट्स

(lambda(n)(dotimes(i n)(format t"~a~a"(1+ i)(- n i))))

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

— रेंज़ो
स्रोत

2

माउस-2002 , ३२ ३० बाइट्स

लूप शुरू करने के लिए -2 सशर्त (z.^ ... ) बजाय(... z.0>^)

?n:n.z:(z.^a.1+a:a.!z.!z.1-z:)

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

स्पष्टीकरण:

?n:                                 ~ get input and store in n
   n.z:                             ~ copy n into z
       (z.^                         ~ stop if z equals 0
           a.1+a:                   ~ add 1 to a
                 a.!                ~ print a
                    z.!             ~ print z
                       z.1-z:)      ~ substract 1 from z

— MooseOnTheRocks
स्रोत

1

दरअसल , 9 बाइट्स

R;R@Z♂iεj

इसे ऑनलाइन आज़माएं! , या सभी परीक्षण मामलों को चलाएं

स्पष्टीकरण:

R;R@Z♂iεj
R          range(1, n+1)
 ;R        duplicate and reverse
   @Z      swap and zip
     ♂i    make 1D
       εj  join with empty string

— मेगो
स्रोत

1 से n तक इंटरलेव नंबर, उसी संख्या के साथ उलटा

एक साधारण एक:

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

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

कैसे?

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

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

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

दे घुमा के , 25 बाइट्स

आर, 35 बाइट्स

05AB1E , 6 5 बाइट्स

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

व्याख्या

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

स्पष्टीकरण:

व्हॉट्सएप , 71 बाइट्स

व्याख्या

हास्केल, 65 48 47 बाइट्स

अजगर, 7 बाइट्स

स्पष्टीकरण:

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

पर्ल 6 , 20 बाइट्स

विस्तारित:

जावा 61 बाइट्स

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

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

रोड़ा , 21 19 बाइट्स

व्याख्या

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

एसीटो , 25 22 बाइट्स

स्पष्टीकरण:

आर, 41 बाइट्स

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

व्याख्या

MATL, 13 11 9 बाइट्स

PHP, 36 35 29 बाइट्स

वी , 20 बाइट्स

क्यूबिक्स , 17 बाइट्स

के (ngn / k) , 16 बाइट्स

मैथॉल्फ , 5 बाइट्स

स्पष्टीकरण:

आम लिस्प, 63 54 बाइट्स

माउस-2002 , ३२ ३० बाइट्स

दरअसल , 9 बाइट्स