चुनौती

रॉबिन एक तीर के आकार में अपने चरों की घोषणा करना पसंद करता है। यहाँ है कि वह यह कैसे करता है:

किसी भी तार को इनपुट करें
लंबाई चढ़ते हुए उन्हें ऑर्डर करें
मध्य में उनके द्वारा ऑर्डर किए गए आउटपुट को एक नकारात्मक एरोहेड बनाते हैं, जैसे कि (जो भी गोल्फ सबसे अच्छा ऑर्डर करता है):
```
5  or  4
3      2
1      1
2      3
4      5
```

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

इनपुट:

bow
arrows
sheriffOfNottingham
kingRichard
maidMarian
princeJohn
sherwoodForest

आउटपुट:

sheriffOfNottingham
kingRichard
maidMarian
bow
arrows
princeJohn
sherwoodForest

इनपुट:

a
bb
cc

आउटपुट (दोनों मान्य हैं):

bb
a
cc

cc
a
bb

इनपुट:

one
four
seven
fifteen

संभव आउटपुट (केवल अन्य मान्य आउटपुट इसका ऊर्ध्वाधर दर्पण है):

seven
one
four
fifteen

तार camelCase में हैं और कोई संख्या या विशेष वर्ण नहीं हैं, केवल लोअरकेस और अपरकेस अक्षर हैं।
इनपुट आपको कुछ भी हो सकता है: अल्पविराम-एक स्ट्रिंग के रूप में अलग, सरणी, ... किसी भी I / O प्रारूप की अनुमति है।
एक ही लंबाई के साथ तार के बीच, किसी भी आदेश को स्वीकार किया जाता है।

code-golf string sorting

— टेलीपोर्टिंग बकरी
स्रोत

मुझे ऐसा लगता है कि पहले भी इसी तरह की चुनौती थी ... लेकिन पीपीसीजी में आपका स्वागत है!

— Giuseppe

@Giuseppe हाँ, यही मैंने पोस्ट करने के बाद सोचा, ऐसा कोई तरीका नहीं है जो पहले नहीं किया गया है। क्या अब आप इसे हटाने के साथ ठीक होंगे कि आपने इसका उत्तर दिया है?

— बकरी

1

अच्छी तरह से मैं एक डुबकी के लिए खोज रहा हूं, लेकिन मैं खोज में बहुत अच्छा नहीं हूं ... हमारे पास चुनौतियों को पोस्ट करने के लिए एक सैंडबॉक्स है जो अक्सर चीजों को पकड़ सकता है। अगर आप इसके बारे में चिंतित हैं तो आप इसे हटाने के साथ पूरी तरह से ठीक हैं।

— Giuseppe

1

यह ठीक है, हम सभी शुरुआत से शुरू करते हैं :-)

— Giuseppe

1

क्या आप स्ट्रिंग्स की संख्या के साथ एक टेस्ट केस जोड़ सकते हैं?

— शर्लक

15

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

lambda l:l.sort(key=len)or l[1::2][::-1]+l[::2]

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

— OVS
स्रोत

आपको कुछ सामान को फिर से व्यवस्थित करने की आवश्यकता होगी, लेकिन आप [::-2]सीधे 5 बाइट्स को बचाने के लिए उपयोग कर सकते हैं ।

— शर्लक

@ शर्लक 9 मैंने वह कोशिश की, लेकिन फिर मुझे लंबाई की जांच करनी थी, क्योंकि समान / असमान लंबाई वाली सूचियों को अलग तरीके से संभालना होगा।

— अंडा

पाइथन के लिए भी काम करता है 3. "लैम्ब्डा l:" और "या" को हटा देगा और 11 बाइट्स को बचाने के लिए इसे 2 लाइनों पर बना देगा "अभी भी I / O प्रारूप की अनुमति है"?

— आलू

9

आर , 63 48 बाइट्स

function(L)c(rev(o<-L[order(nchar(L))]),o)[!0:1]

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

स्ट्रिंग की लंबाई के आधार पर क्रमबद्ध करें, फिर क्रमबद्ध सूची के साथ उलट सूची को संयोजित करें, अंत में, 1-आधारित सूचकांक 1 से शुरू होकर, प्रत्येक 2 तत्व को लें।

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

1

o<-L[...दूसरा तरीका 'एरो वैरिएबल' है। एक तरफ कम महत्वपूर्ण, pryr::f(...)46 के लिए यहां काम करता है। इसे ऑनलाइन आज़माएं!

— क्रिमिनल

@CriminallyVulgar को अतिरिक्त पुस्तकालयों का उपयोग करने से यह एक अलग भाषा में बदल जाता है, R + pryrयही कारण है कि मैं आमतौर पर ऐसा करने से बचता हूं , जब तक कि एक अच्छा कारण नहीं है - जैसे संख्या सिद्धांत प्रश्नों के लिए, numbersअपरिहार्य है।

— ग्यूसेप

7

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

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

s=>s.sort((a,b)=>a.length-b.length).reduce((m,x,i)=>i%2?[...m,x]:[x,...m],[])

व्याख्या

s =>                                 // take input as an array of strings s
  s.sort((a,b)=>a.length-b.length)   // sort input by string length
  .reduce(                           // reduce
    (m,x,i)=>i%2?[...m,x]:[x,...m],  // if index is even, stick string x at the end of the memo
                                     // array, else at the beginning
    []                               // memo initialized to empty array
  )

— asgallant
स्रोत

1

मुझे नहीं लगता कि आपको गिनना होगा f=। 77

— दाना

जो मैंने देखा है उससे js कोड गोल्फ सबमिशन में असंगत है। अगर इसे नहीं गिना जाए तो मुझे इसे बाहर करने में खुशी होगी।

— asgallant

2

मुझे लगता है कि यह निर्भर करता है कि आपका फ़ंक्शन पुनरावर्तन का उपयोग करता है या नहीं। यानी f=x=>x?f(x-1)। यदि हां, तो आपको fइसे अपने फ़ंक्शन में कॉल करने के बाद से शामिल करने की आवश्यकता है । हालाँकि, चूंकि आप पुनरावृत्ति का उपयोग नहीं कर रहे हैं, इसलिए आपको शामिल नहीं करना चाहिए f। मेटा में कई पोस्ट हैं, यह एक इसे थोड़ा बेहतर समझाता है। codegolf.meta.stackexchange.com/a/9032/8340

— dana

मैंने जो विसंगतियां देखी हैं, उन्हें समझाऊंगा।

— 16

5

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 89 बाइट्स

n=>(n=n.OrderBy(x=>x.Length)).Where((a,b)=>b%2>0).Reverse().Concat(n.Where((a,b)=>b%2<1))

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

— अज्ञान का अवतार
स्रोत

5

के (ओके) , 24 बाइट्स

समाधान:

x(<#:'x)(|&~w),&w:2!!#x:

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

स्पष्टीकरण:

6 4 2 0 1 3 5अनुक्रम उत्पन्न करें , इनपुट के आरोही लंबाई में अनुक्रमित करने के लिए उपयोग करें और मूल सरणी में अनुक्रमित करने के लिए इसका उपयोग करें:

x(<#:'x)(|&~w),&w:2!!#x: / the solution
                      x: / save input as x
                     #   / count (#) of x
                    !    / range 0 to ...
                  2!     / modulo 2
                w:       / save as w
               &         / indices where true
              ,          / join with
        (    )           / do this together
           ~w            / not (~) w
          &              / indices where true
         |               / reverse
 (     )                 / do this together
   #:'x                  / count (#:) of each (') x
  <                      / indices to sort ascending
x                        / index into x

— streetster
स्रोत

5

जेली , ९ by बाइट्स

LÞŒœm"-Ẏ

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

LÞŒœṚ;¥/

8 बाइट्स भी है।

एक बाइट को बचाने के लिए गोल्फ की पेशकश करने के लिए @EriktheOutgolfer और @JonathanAllan के लिए धन्यवाद।

— निक केनेडी
स्रोत

अच्छा! चतुर गोल्फ: Ṛ€1¦बन सकता है m"-।

— आउटगोल्फर

या आप के लिए जा सकते हैंLÞŒœṚ;¥/

— जोनाथन एलन

5

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

->l{r=1;l.sort_by!(&:size).map{l[r-=2]||(l*2)[~r]}}

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

— जीबी
स्रोत

5

05AB1E , 6 5 बाइट्स

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

I / O स्ट्रिंग्स की एक सूची है।
लिंक को आसान परीक्षण के लिए अलग किए गए I / O के लिए संशोधित किया गया है।

éι`Rì

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

व्याख्या

é       # sort by length ascending
 ι      # uninterleave into 2 parts, both sorted ascending
   `    # push the 2 parts separately to the stack
    R   # reverse the second part
     ì  # and append it to the first

— Emigna
स्रोत

आप पहली बार हटा सकते हैं Rऔर की जगह «के साथ i, एक बाइट को बचाने के लिए के बाद से तीसरी बुलेट बिंदु नियम uninterleaving के दोनों संस्करणों की अनुमति देता है।

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

@ केविनक्रूजसेन: ओह हाँ, धन्यवाद!

— एमिग्ना

5

जे , 11 बाइट्स

,~`,/@\:#&>

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

हम इसे पहले हल करते हैं।

फिर हम सूची फ़ॉर्म को दाईं ओर से बाईं ओर कम करते हैं, लेकिन वैकल्पिक रूप से हम नए तत्व को किस तरफ रखते हैं। किया हुआ।

— जोनाह
स्रोत

बहुत अच्छा! आपके पास अंत में एक स्थान है, हालांकि, इसे 11 बाइट्स के लिए हटा दें :)

— गैलेन इवानोव

1

धन्यवाद गैलेन। फिक्स्ड!

— योना

4

पॉवरशेल , 66 बाइट्स

1..($a=$args|sort l*).count|?{$_%2}|%{$a[-$_];$x=,$a[-++$_]+$x};$x

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

स्प्लिटिंग के माध्यम से इनपुट लेता है, जो TIO पर अलग-अलग कमांड-लाइन तर्कों के रूप में प्रकट होता है। ength sortपर s l, उस में स्टोर करता है $a, और इनपुट स्ट्रिंग्स 1तक एक सीमा countबनाता है। हम तो केवल विषम लोगों को बाहर निकालते हैं ?{$_%2}और उन्हें एक लूप में खिलाते हैं |%{...}। प्रत्येक पुनरावृत्ति, हम "अंतिम", फिर "अंतिम से तीसरा", और इसी तरह से पाइप लाइन पर डालते हैं $a[-$_]। अलग-अलग, हम $x"दूसरे से अंतिम", "अंतिम से चौथे" आदि में भी जमा होते हैं , लूप से बाहर और पाइपलाइन को फ्लश किया जाता है (इसलिए वे तत्व आउटपुट होते हैं) और फिर हम आउटपुट करते हैं $x। दोनों उदाहरणों में, डिफ़ॉल्ट आउटपुट हमें स्वचालित रूप से आइटमों के बीच नई स्थिति देता है।

— AdmBorkBork
स्रोत

4

PHP ,144 141 बाइट्स

function($a){usort($a,function($b,$c){return strlen($b)-strlen($c);});$e=[];foreach($a as$d)(array_.[unshift,push][++$i%2])($e,$d);return$e;}

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

-3 बाइट्स @Ismael मिगुएल को धन्यवाद !

— 640KB
स्रोत

अच्छा है। मैं इसके बारे में और कहाँ पढ़ सकता हूँ [array_unshift,array_push][++$i%2]($e,$d)?

— abhig10 10

2

@ abhig10 पक्का। यह दो समारोह नाम के साथ एक सरणी है ['array_push','array_unshift']के साथ [++$i%2]एक के बीच सरणी बारी के सूचकांक के रूप में 0या 1तो अन्य कार्य करने के लिए हर बार का मूल्यांकन करेंगे। PHP के "वैरिएबल फ़ंक्शंस" आपको एक फ़ंक्शन के लिए एक वेरिएबल असाइन करते हैं और कोष्ठक (उदा: $f='array_push'; $f($e,$d);== array_push($e,$d)) के साथ कॉल करके निष्पादित करते हैं ($e,$d), इसलिए वह तब सरणी के मूल्यांकन किए गए तत्व को बुला रहा है। बस एक छोटा तरीका है if (++$i%2) array_push($e,$d); else array_unshift($e,$e);। लगता है कि सब के बाद कुछ PHP सिंथैटिक चीनी थी!

— 640KB

ठीक है, मुझे यह समझने में कुछ समय लगा। बहुत बढ़िया।

— abhig10

1

आप की जगह 3 बाइट्स बचा सकता है [array_unshift,array_push][++$i%2]($e,$d)के साथ (array_.[unshift,push][++$i%2])($e,$d)। मैंने जो किया था उसे दोहराया array_, संक्षिप्त किया और फिर परिणाम कॉल को पास किया गया।

— इस्माइल मिगुएल

1

@IsmaelMiguel शानदार है। धन्यवाद!

— 640KB

4

MATLAB, 87 बाइट्स

function f(y);[B,I]=sort(cellfun(@(x)length(x),y));{y{flip(I(1:2:end))},y{I(2:2:end)}}'

स्ट्रिंग्स के सेल ऐरे के रूप में इनपुट लेता है, स्ट्रिंग्स के कॉलम को आउटपुट करता है (यदि यह कानूनी है तो सुनिश्चित नहीं है)

> s = {'qweq qwe qw','qweqw','12132132131231231','asdasdasda','qwe','w'};
> f(s)
> >> 
> ans =
> 
>   6×1 cell array
> 
>     {'qweq qwe qw'      }
>     {'qweqw'            }
>     {'qwe'              }
>     {'1234'             }
>     {'asdasdasda'       }
>     {'12132132131231231'}

पुनश्च: अजीब लंबाई इनपुट के साथ एक बग की ओर इशारा करने के लिए धन्यवाद Sanchises

— आआआआ कहती है मोनिका को बहाल करो
स्रोत

यह इनपुट स्ट्रिंग्स की विषम संख्या पर विफल रहता है, जैसेf({'loooooooong','medium','short'})

— Sanchises

इसके अलावा कुछ सामान्य गोल्फ युक्तियाँ: एक के endलिए वैकल्पिक है function। का उपयोग करने function x=f(y);x={...}'से कम है function f(y);disp({...}')।

— Sanchises

यदि आप फंस गए हैं, तो यहां बताया गया है कि मैं यह कैसे करूंगा।

— Sanchises

@ बग को इंगित करने के लिए धन्यवाद का धन्यवाद। मैंने इसे ठीक किया जैसे आपने किया। के साथ मेरा मुद्दा dispहै मुझे यकीन नहीं है कि आउटपुट नियम क्या हैं। यह शुद्ध पाठ होना चाहिए या नहीं? या disp({...})ठीक है या यहां तक कि जैसा x={...}कि आप सुझाव देते हैं

— आआआआ कहते हैं मोनिका

1

ऑक्टेव में यह 58 बाइट्स हो सकता है ।

— Giuseppe

3

एपीएल (Dyalog यूनिकोड) , 18 बाइट्स ^SBCS

{⍵[⍋-@(2∘|)⍋⍋≢¨⍵]}

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

@Ngn के लिए बग का धन्यवाद तय किया।

स्पष्टीकरण:

{⍵[⍋-@(2∘|)⍋⍋≢¨⍵]}
{                } ⍝ Function. Takes a single argument: ⍵, list of strings
             ≢¨⍵   ⍝ The length of each element in the list
           ⍋⍋      ⍝ Sort the lengths
    -@(2∘|)        ⍝ At (@) elements divisible by 2 (|), negate (-)
                   ⍝     gives -1 2 -3 4 -5
   ⍋               ⍝ Sort this list again, gives the indices of that list ^ sorted
 ⍵[             ]  ⍝ Use these indices to index into the argument

¹

— Ven
स्रोत

1

≢¨×¯1*⍳∘⍴-> (⊢∘-\≢¨)और अगर आप इसे dfn में बदल देते हैं तो यह और भी कम हो जाता है

— ngn

1

हालाँकि, मुझे यकीन नहीं है कि यह एल्गोरिथ्म सही है। हमें उनके छांटे गए क्रम में हर दूसरे तार की लंबाई को नकारना चाहिए, न कि वे इनपुट से आने वाले क्रम में

— nnn

2

एपीएल + विन, 31 38 बाइट्स

एडम्स टिप्पणी देखें

⊃n[(⍳⍴n)~a],⌽n[a←2×⍳⌊.5×⍴n←n[⍒∊⍴¨n←⎕]]

यह Dyalog क्लासिक के सौजन्य से ऑनलाइन कोशिश करो!

तार के एक नेस्टेड वेक्टर के लिए संकेत

— ग्राहम
स्रोत

क्या एपीएल + की ≢जगह मोनाडिक "टैली" नहीं है ∊⍴?

— 19

1

पर विफल रहता है '12' '1234' '1234' '1234' '1234' '12345678' '12345678' '12345678' '12345678'। जाहिर है, परिणाम होना चाहिए था'12345678' '12345678' '1234' '1234' '12' '1234' '1234' '12345678' '12345678'

— Adám

@ Adám मेरे प्राचीन संस्करण APL + में ancient नहीं है। आपकी दूसरी टिप्पणी पर सहमत मैं कल इस पर एक नज़र डालूंगा।

— ग्राहम

2

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

N$`
$.&
*\,2,^A`.+
,2,G`.+

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

N$`
$.&

लंबाई के आरोही क्रम में लाइनों को क्रमबद्ध करें ( $.&रेखा की लंबाई लौटाता है)।

*\,2,^A`.+

अस्थायी रूप से वैकल्पिक लाइनें हटाएं और शेष लाइनों को रिवर्स ऑर्डर में आउटपुट करें।

,2,G`.+

केवल वही लाइनें रखें जो अस्थायी रूप से हटा दी गई थीं और उन्हें आउटपुट करती हैं।

— नील
स्रोत

2

गैया , 10 बाइट्स

el∫v:v+2%ụ

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

e		| eval as Gaia code (list of strings)
 l∫		| ∫ort by lengths (ascending)
   v:v		| reverse, dup, reverse
      +		| concatenate lists
       2%	| take every other element
         ụ	| join by newlines and output

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

4

मुझे यह पसंद है कि आपके कोड में कोई टिप्पणी नहीं है, तार के तीर के रूप में

— आआआआ कहती है मोनिका

2

जाप, 8 बाइट्स

ñÊó g0_w

-3 बाइट्स झबरा धन्यवाद!

कोशिश करो

— अज्ञान का अवतार
स्रोत

एक 2-सरणी के रूप में आउटपुट के साथ 10 बाइट्स , जो कि अनुमति दी जाएगी।

— झबरा

या, शायद, 8 बाइट्स ? मेरे फोन पर तो यह ठीक से परीक्षण नहीं किया है।

— झबरा

@ शैग्गी मैं प्रत्येक एनएचटी तत्व को खोजने के लिए एक फंक्शन की तलाश में था, लेकिन मैं इसे नहीं ढूंढ सका। धन्यवाद!

— को इग्नोरेंस

वहाँ भी है, A.ë()लेकिन मुझे नहीं पता कि यह एक छोटे समाधान के लिए नेतृत्व करेंगे।

— झबरा

2

पॉवरशेल , 49 बाइट्स

$args|sort l*|sort{$_.Length*($global:x=-$x*2+1)}

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

दोहरा आसवन ।

— Mazzy
स्रोत

2

टी-एसक्यूएल, 84 बाइट्स

इनपुट एक तालिका चर है

SELECT a FROM(SELECT*,row_number()over(order by len(a))r
FROM @)x order by(r%2-.5)*r

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

— t-clausen.dk
स्रोत

2

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

*.sort(&chars).sort:{$++%2*$--}

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

स्ट्रिंग की लंबाई के आधार पर, फिर स्थिर क्रम से 0, -1, 0, -3, 0, -5, ...

— nwellnhof
स्रोत

1

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

s=>s.sort((x,y)=>x.length-y.length).reduce((a,e,i)=>{i%2?a.push(e):a.unshift(e);return a;},[]);

— somsom
स्रोत

-1 s.sort()स्ट्रिंग्स को लंबाई से नहीं, मूल रूप से स्ट्रिंग्स को क्रमबद्ध करें।

— asgallant

राइट (x, y) => x.length-y.length, उसे ठीक करना चाहिए।

— सोमसोम

1

रेड , 116 101 बाइट्स

func[b][sort/compare b func[x y][(length? x)> length? y]collect[forall b[keep take b]keep reverse b]]

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

— गैलेन इवानोव
स्रोत

1

पर्ल 5 ( `-p0777F/\n/ -M5.01`), 59 बाइट्स

for$x(sort{$b=~y///c-length$a}@F){--$|?$\="$x
".$\:say$x}}{

TIO

— नहुएल फौलीउल
स्रोत

1

सी (जीसीसी) , 136 128 बाइट्स

S(a,b)int**a,**b;{a=strlen(*b)-strlen(*a);}f(l,s,o,i,b,e)int**s,**o;{qsort(s,l,8,S);e=l-1;for(i=b=0;i-l;)o[i++%2?b++:e--]=s[i];}

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

-8 बाइट्स सीलिंगकैट के लिए धन्यवाद।

फ़ंक्शन fइसका समाधान है। यह स्ट्रिंग्स की संख्या, स्ट्रिंग्स को स्वयं और आउटपुट बफर को तर्क के रूप में लेता है (साथ ही आंतरिक रूप से उपयोग किए जाने वाले चार और)।

— LambdaBeta
स्रोत

आउटपुट./.bin.tio में क्यों है ?

— बकरी

@TeleportingGoat शायद, क्योंकि उनका पाद लेख सभी का उपयोग कर रहा है argv, जिसमें फ़ाइल नाम भी शामिल है

— Jo King

वास्तव में, यह सिर्फ एक त्वरित परीक्षण था। कोई भी ऐसे डेटा का निर्माण कर सकता है जो उपयुक्त प्रारूप लेता है। मैं TIO लिंक को बाद में अपडेट करूंगा।

— लैम्ब्डाटा

हाहा, इन छोटे चर नामों के साथ समस्या: आप भूल जाते हैं कि आप tपहली जगह में क्या नफरत करते हैं और इसे तब भी अपने पास रखें जब आपको इसकी आवश्यकता न हो!

— लैंबडाबेटा

122 बाइट्स

— सीलिंगकैट

0

जाप , 8 बाइट्स

लाइनों के एक सरणी के रूप में इनपुट, लाइनों के 2 सरणियों के एक सरणी के रूप में आउटपुट, सूची के प्रत्येक आधे के लिए एक।

ñÊó
hUÎÔ

इसे आज़माएँ (I / O के लिए अनुमति देने के लिए अतिरिक्त कोड के रूप में newline अलग स्ट्रिंग)

ñÊó      :Implicit input of array U
ñ        :Sort by
 Ê       :  Length
  ó      :Uninterleave

hUÎÔ     :Newline reassigns to U
h        :Set the first element in U to
 UÎ      :  The first element in U
   Ô     :  Reversed

— झबरा
स्रोत

0

हास्केल , 104 96 बाइट्स

import Data.List
f s=splitAt((length s+1)`div`2)s
g=sortOn length
h(x,y)=reverse(g x)++g y
z=h.f

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

— कीड़े
स्रोत

अमान्य, आपको सूची को आधे में काटने से पहले छाँटना होगा

— ASCII-only

90

— एएससीआईआई-केवल

तीर उन चर!

चुनौती

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

टिप्पणियाँ

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

आर , 63 48 बाइट्स

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

व्याख्या

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 89 बाइट्स

के (ओके) , 24 बाइट्स

जेली , ९ by बाइट्स

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

05AB1E , 6 5 बाइट्स

जे , 11 बाइट्स

पॉवरशेल , 66 बाइट्स

PHP ,144 141 बाइट्स

MATLAB, 87 बाइट्स

एपीएल (Dyalog यूनिकोड) , 18 बाइट्स ^SBCS

एपीएल + विन, 31 38 बाइट्स

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

गैया , 10 बाइट्स

जाप, 8 बाइट्स

पॉवरशेल , 49 बाइट्स

टी-एसक्यूएल, 84 बाइट्स

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

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

रेड , 116 101 बाइट्स

पर्ल 5 ( `-p0777F/\n/ -M5.01`), 59 बाइट्स

सी (जीसीसी) , 136 128 बाइट्स

जाप , 8 बाइट्स

हास्केल , 104 96 बाइट्स

तीर उन चर!

चुनौती

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

टिप्पणियाँ

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

आर , 63 48 बाइट्स

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

व्याख्या

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 89 बाइट्स

के (ओके) , 24 बाइट्स

जेली , ९ by बाइट्स

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

05AB1E , 6 5 बाइट्स

जे , 11 बाइट्स

पॉवरशेल , 66 बाइट्स

PHP ,144 141 बाइट्स

MATLAB, 87 बाइट्स

एपीएल (Dyalog यूनिकोड) , 18 बाइट्स SBCS

एपीएल + विन, 31 38 बाइट्स

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

गैया , 10 बाइट्स

जाप, 8 बाइट्स

पॉवरशेल , 49 बाइट्स

टी-एसक्यूएल, 84 बाइट्स

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

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

रेड , 116 101 बाइट्स

पर्ल 5 ( -p0777F/\n/ -M5.01), 59 बाइट्स

सी (जीसीसी) , 136 128 बाइट्स

जाप , 8 बाइट्स

हास्केल , 104 96 बाइट्स

एपीएल (Dyalog यूनिकोड) , 18 बाइट्स ^SBCS

पर्ल 5 ( `-p0777F/\n/ -M5.01`), 59 बाइट्स