चुनौती

स्टडर्स, फ़ंक्शन तर्क, प्रोग्राम तर्क या किसी अन्य विधि से प्राप्त पूर्णांक की एक सरणी को देखते हुए:

सरणी में केवल न्यूनतम और अधिकतम संख्याओं का आउटपुट , वापसी मान, स्टडआउट या अन्य फिटिंग विधियों के माध्यम से।

उदाहरण सत्र

> minmax( {0, 15, 2, 3, 7, 18, -2, 9, 6, -5, 3, 8, 9, -14} )
-14 18

संदर्भ कार्यान्वयन

// C++14

void minmax(std::vector<int> v) {
    int min = v[0]; int max = v[0];
    for(auto it : v) {
        if (*it < min)
            min = *it;
        if (*it > max)
            max = *it;
    }
    std::cout << min << ' ' << max << std::endl;
}

नियम

आप मानों की गणना करने के लिए एक अंतर्निहित फ़ंक्शन का उपयोग नहीं कर सकते हैं।
मानक खामियों को दूर किया।
रचनात्मक कार्यान्वयन को प्रोत्साहित किया।
यह कोड-गोल्फ है , सबसे छोटी उत्तर जीत है लेकिन चयनित नहीं होगी।

स्पष्टीकरण

यदि सरणी में 1 तत्व है तो आपको इसे दो बार आउटपुट करने की आवश्यकता है।
यदि न्यूनतम और अधिकतम मान समान हैं, तो आपको उन दोनों को आउटपुट करने की आवश्यकता है।

code-golf number array-manipulation

— dkudriavtsev
स्रोत

12

यह Y चुनौती के बिना एक एक्स है , जो विशेष रूप से दिलचस्प नहीं हैं।

— मेगो

5

@DmitryKudriavtsev अगली बार सैंडबॉक्स आज़माएं ।

— मेगो

5

गंभीरता से, सैंडबॉक्स का उपयोग करें । चुनौती में आपके परिवर्तनों ने हर एक उत्तर को अमान्य कर दिया है।

— Mego

1

मैंने रचनात्मक विधियों को प्रोत्साहित किया नहीं, आपने लघु समाधानों को प्रोत्साहित किया, इसे टैग करकेcode golf

— लुइस मेंडो

1

जैसा कि लुइस मेंडो ने कहा, हां, हर कोई पोस्ट कर रहा है "मैं आपके सरणी को एक अंतर्निहित और पहले और आखिरी का उपयोग करके सॉर्ट कर रहा हूं", विभिन्न भाषाओं में, वास्तव में रचनात्मक नहीं: x

— वॉलफ्रैट

29

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

Ṣ.ị

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

सरणी को सॉर्ट करें, और फिर 0.5-वें तत्व को लेता है।

जेली 1-इंडेक्सिंग का उपयोग करती है, और फ्लोटिंग पॉइंट इंडेक्सिंग का अर्थ है इसके फर्श और इसकी छत को लें।

तो 0.5-वें तत्व आपको 0 तत्व और 1 तत्व देगा।

0 तत्व अंतिम तत्व है।

— लीक नन
स्रोत

2

सुंदर चतुर मैं इसके लिए इंतज़ार कर रहा हूँ .... जेली!

— रोहन झुनझुनवाला

ओह, ताकि मध्ययुगीन तुच्छ खोज हो।

— आदम

1

@KonradRudolph यह ।

— लीक नून

1

क्या आप पहले दो तत्वों के बजाय पहला और अंतिम तत्व नहीं चाहते हैं? या मैंने आपके स्पष्टीकरण को गलत समझा है?

— टोबी स्पाइट

1

@TobySpeight 1-आधारित इंडेक्सिंग में 0 तत्व अंतिम तत्व है।

— लीक नुन्

12

पायथन, 61 49 37 36 34 31 बाइट्स

lambda s:s.sort()or[s[0],s[-1]]

-12 बाइट्स RootTwo को धन्यवाद

एक और -12 बाइट्स चेपनर के लिए धन्यवाद

-2 बाइट्स जॉनलेट को धन्यवाद

जॉन बाईट को -3 बाइट्स धन्यवाद

— acrolith
स्रोत

1

मैंने हेडिंग को पायथन में बदल दिया क्योंकि यह पायथन 3 में भी काम करता है।

— लीक नून

1

आप एक दर्जन बाइट्स को बंद कर सकते हैं: [::(len(s)-1)or 1]पहली सबस्क्रिप्ट के लिए उपयोग करें । और दूसरे कार्यकाल को छोटा किया जा सकता है s[:len(s)<2]।

— रूटट्वो

दो बार सूची को छाँटने की कीमत पर, आप एक और 12 बाइट्स से दाढ़ी बना सकते हैं lambda s:sorted(s)[:1]+sorted(s)[-1:]:।

— chepner

6 बाइट्स बचाकरlambda s:sorted(s)[::len(s)-1]

— हारून

वर्तमान संस्करण ( lambda s:sorted(s)[::len(s)-1]) एक तत्व के साथ सरणियों के लिए काम नहीं करता है ( ValueError: slice step cannot be zero)। एक संभावित फिक्स lambda s:sorted(s*2)[::len(s*2)-1](34 बाइट्स) होगा।

— जॉन्लेट

8

ब्रेन-फ्लैक 220 218 बाइट्स

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

यह ऑनलाइन की कोशिश करो!

व्याख्या

पहले यह शीर्ष मूल्य को दोगुना कर देता है (सूची में केवल एक लंबा है)

(({}))

तब यह मेरे बबल सॉर्ट एल्गोरिथ्म का उपयोग करता है:

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

फिर यह स्टैक के शीर्ष मूल्य (यानी मिनट) को चुनता है

({}<...>)

तब तक पॉप होता है जब तक कि स्टैक की ऊंचाई एक नहीं हो जाती:

((())){{}{}([][()])}{}

— पोस्ट रॉक गार्फ हंटर
स्रोत

8

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

a=>[a.sort((x,y)=>x-y)[0],a.pop()]

sortसॉर्ट-इन-प्लेस, इसलिए मैं केवल popएरे से सबसे कम मूल्य और उच्चतम मूल्य के लिए [0] इंडेक्स का उल्लेख कर सकता हूं , हालांकि यह डिफ़ॉल्ट रूप से एक स्ट्रिंग सॉर्ट करता है इसलिए मुझे एक तुलनित्र पास करना होगा।

— नील
स्रोत

मुझे नहीं लगता कि आपको उस (x,y)=>x-yहिस्से की ज़रूरत है , जब तक sort()कि डिफ़ॉल्ट एल्गोरिथ्म के साथ उपयोग करना बिलियन के रूप में मायने नहीं रखता है।

— स्कॉट

1

@ लेकिन मुझे एक शाब्दिक प्रकार नहीं चाहिए ...

— नील

ठीक है ... मैंने इसे संख्याओं के साथ परीक्षण नहीं किया> 10 या <0. मैं sort()आंतरिक रूप से सब कुछ तार के रूप में नहीं जानता - क्षमा करें!

— स्कॉट

5

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

Sort[#][[{1,-1}]]&

सरणी को सॉर्ट करता है और पहले और अंतिम मान निकालता है।

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

5

आर, 31 बाइट्स

l=sort(scan());l[c(1,sum(l|1))]

यह मूल नहीं है , लेकिन हे!

— फ़्रेडरिक
स्रोत

5

एआरएम मशीन कोड, 26 बाइट्स

हेक्स डंप (थोड़ा एंडियन):

6810 4601 f852 cb04 4560 bfc8 4660 4561 bfb8 4661 3b01 d8f5 4770

यह एक फ़ंक्शन है, जिसमें कोई सिस्टम कॉल या लाइब्रेरी निर्भरता नहीं है। एन्कोडिंग थम्ब -2, एक चर (2 या 4 बाइट) 32-बिट एआरएम के लिए एन्कोडिंग है। जैसा कि कोई कल्पना कर सकता है, यहां पहले और अंतिम तत्वों को चुनने और चुनने का कोई आसान तरीका नहीं है। कुल मिलाकर, वास्तव में ऐसा कुछ भी नहीं है जो यहां चल रहा है, यह संदर्भ के कार्यान्वयन के समान है।

असंगठित विधानसभा (GNU वाक्य-विन्यास):

.syntax unified
.text
.global minmax
.thumb_func
minmax:
    @Input: @r0 and r1 are dummy parameters (they don't do anything)
    @r2 - Pointer to list of integers (int*)
    @r3 - Number of integers to sort (size_t)
    @Output:
    @Minimum of the list in r0 (int)
    @Maximum in r1 (int)
    ldr r0,[r2] @min=r2[0]
    mov r1,r0 @max=min
    loop:
        @ip is intra-procedure call register, a.k.a. r12
        ldr ip,[r2],#4 @ip=*r2++
        cmp r0,ip
        it gt @if (r0>ip)
        movgt r0,ip @r0=ip
        cmp r1,ip
        it lt @if (r1<ip)
        movlt r1,ip @r1=ip
        subs r3,r3,#1
        bhi loop @while (--r3>0)
    bx lr @Return

रास्पबेरी पाई 3 पर परीक्षण किया गया; यहाँ परीक्षण स्क्रिप्ट (C99, argv के माध्यम से इनपुट):

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
//First 2 arguments are dummies.
uint64_t minmax(int,int,int* array,size_t size);

int main(int argc,char** argv) {
    int i;
    int array[argc-1];
    for (i=1;i<argc;i++) {
        array[i-1]=atoi(argv[i]);
    }
    uint64_t result = minmax(0,0,array,argc-1);
    printf("Minimum is %d, maximum is %d.\n",(unsigned)result,(unsigned)(result>>32));
}

— इयान च्यू
स्रोत

4

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

f x=(`foldl1`x)<$>[min,max]

हास्केल में, minऔर maxन्यूनतम और अधिकतम दो तर्क दें, सूची के नहीं। मैं नहीं बता सकता कि क्या यह अस्वीकृत है (ऐसा लगता है कि इसके बजाय केवल minimumऔर maximumअस्वीकृत होगा) तो कृपया मुझे बताएं कि क्या वे हैं और मैं तुरंत इस उत्तर को हटा दूंगा।

— माइकल क्लेन
स्रोत

@nimi FGITW प्रभाव, दुख की बात है ...

— थ्री एफएक्स

3

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

@(n)sort(n)([1,end])

यह इनपुट वेक्टर को सॉर्ट करता है और पहले और अंतिम मान को आउटपुट करता है।

— flawr
स्रोत

3

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

S;F@N

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

स्पष्टीकरण:

S;F@N
S      sort
 ;     dupe
  F    first element
   @N  and last element

— मै जाऊं
स्रोत

3

05AB1E , 6 4 बाइट्स

{Âø¬

व्याख्या

{     # sort list
 Â    # bifurcate
  ø   # zip
   ¬  # head

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

— Emigna
स्रोत

3

MATL , 4 बाइट्स

S5L)

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

व्याख्या

S    % Implicitly input the array. Sort
5L   % Push [1 0]. When used as a (modular, 1-based) index, this means "first and last"
)    % Apply as an indexing vector into the sorted array. Implicitly display

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

3

पायथन, 29 बाइट्स

lambda s:s[s.sort():1]+s[-1:]

Ideone पर इसका परीक्षण करें ।

— डेनिस
स्रोत

3

सी, 83 81 79 बाइट्स

m,M;f(a,s)int*a;{for(m=M=*a;s--;++a)*a<m?m=*a:*a>M?M=*a:0;pr‌intf("%i %i",m,M);}

— NoSeatbelts
स्रोत

1

घोषणा में बदल सकते हैं ...f(a,s)int*a{...प्रति इस

— बिल्ली

1

आप अन्य 2 बाइट्स को प्राप्त करने के लिए टर्नरी अभिव्यक्तियों को जोड़ सकते हैं:m,M;f(a,s)int*a;{for(m=M=*a;s--;++a)*a<m?m=*a:*a>M?M=*a:0;printf("%i %i",m,M);}

— गैस्ट्रोपनर

में gccआप की जगह ले सकता *a>M?M=*a:0साथ*a<M?:M=*a

— ceilingcat

2

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

oOtT,Oh:T

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

— लीक नन
स्रोत

2

वी , 12 बाइट्स

:sor
ò2Gjkd

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

इसके लिए DJMcMayhem को श्रेय।

— Rɪᴋᴇʀ
स्रोत

1

\o/हाँ, मैं अब इस भाषा का उपयोग करने वाला एकमात्र व्यक्ति नहीं हूँ!

— जेम्स

1

यदि इनपुट एक एकल संख्या है, तो उस संख्या को अभी भी दो बार आउटपुट होना है

— लुइस मेंडो

@LuisMendo hm, उस पर काम करेगा।

— R

2

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

q~$_(p;W>

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

मैं वास्तव में सीजेएम में अच्छा नहीं हूं।

q~          e# eval input
  $         e# sort
   _        e# duplicate
    (       e# pop first
     p      e# print
      ;     e# remove array
       W>   e# get last element

— PurkkaKoodari
स्रोत

किसी सूची का पहला तत्व प्राप्त करने का सामान्य तरीका है 0=(लेकिन दुर्भाग्य से यह किसी भी बाइट को नहीं बचाता है)। दो अन्य 9-बाइट समाधान: 0W]q~$f=pया अनाम ब्लॉक {$2*_,(%}।

— मार्टिन एंडर

8 बाइट्स q~$(p)p;:। आप )अंतिम तत्व प्राप्त करने के लिए उपयोग कर सकते हैं जैसे आप (पहले प्राप्त करने के लिए उपयोग करते हैं।

— बिजनेस कैट

@BusinessCat मूल रूप से मेरे पास यही था, लेकिन यह एकल-तत्व इनपुट के लिए विफल रहता है।

— पुरकाकूदरी

@ Pietu1998: ओह, आप सही कह रहे हैं। मैंने उस पर ध्यान नहीं दिया।

— बिजनेस कैट

2

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

x=sorted(input());print x[0],x[-1]

— नीला
स्रोत

2

PHP, 44 बाइट्स

function a($a){sort($a);echo $a[0].end($a);}

— DEXA
स्रोत

2

प्रसंस्करण, 59 52 बाइट्स

void m(int[]x){x=sort(x);print(x[0],x[x.length-1]);}

प्रसंस्करण वास्तव में मुझे उस स्टड से पढ़ने की अनुमति नहीं देता है जिसे मैं खोजने में सक्षम रहा हूं, और मुझे नहीं पता कि क्या इसका आंतरिक जावा कंपाइलर लैम्ब्डा का समर्थन करता है (और इसके इतने लंबे समय से मुझे गंभीर जावा लिखना है कि मैं डॉन 'याद नहीं कैसे)।

— कोड़ी
स्रोत

आप बाद में रिक्त स्थान को हटाकर बाइट्स बचा सकते हैंint[]

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

1

पर्ल 6 13 बाइट्स

*.sort[0,*-1]

परीक्षा:

my &min-max = *.sort[0,*-1];

say min-max 1;
# (1 1)
say min-max (0, 15, 2, 3, 7, 18, -2, 9, 6, -5, 3, 8, 9, -14)
# (-14 18)

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

डार, तुम मुझे वहाँ हरा दो!

— bb94

1

सी #, 60 बाइट्स

n=>{System.Array.Sort(n);return new[]{n[0],n[n.Length-1]};};

93 बाइट्स में एक भोली विधि:

n=>{var r=new[]{n[0],n[0]};foreach(int i in n){if(i<r[0])r[0]=i;if(i>r[1])r[1]=i;}return r;};

— TheLethalCoder
स्रोत

1

POSIX Awk, 44 बाइट्स

awk '{for(;NF-1;NF--)if($1>$NF)$1=$NF}1' RS=

— स्टीवन पेनी
स्रोत

1

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

@(x)[x(all(t=x<=x')) x(sum(t)==1)]

यह एक अन्नमय कोश है। इसे आइडोन पर आज़माएं ।

कोड छँटाई का उपयोग करने से बचता है। अर्थात्, यह इनपुट के तत्वों के बीच सभी युग्मक को "कम या बराबर" तुलना करता है। न्यूनतम वह तत्व है जिसके लिए सभी तुलनाएं सही हैं। अधिकतम वह है जिसके लिए केवल एक तुलना सही है।

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

1

पायथन, 35 34 बाइट्स

lambda s:sorted(s+s[:1])[::len(s)]

वैकल्पिक संस्करण:

lambda s:sorted(s+s)[::len(s)*2-1]

पुराना संस्करण, 35 बाइट्स।

lambda s:sorted(s+[s[0]])[::len(s)]

काफी सरल: इनपुट सूची को लें, पहले तत्व को जोड़ें, उसे क्रमबद्ध करें, फिर परिणामी सूची के पहले और (लंबाई) वें तत्व को लें। जैसा कि किसी तत्व को जोड़ने के बाद इनपुट की लंबाई + 1 है, यह उक्त सूची का पहला और अंतिम तत्व लेता है, जो न्यूनतम और अधिकतम तत्व हैं।

— TLW
स्रोत

1

हालांकि पायथन में सबसे छोटा जवाब नहीं है, यह बहुत ही रचनात्मक है! +1

— mbomb007

34-बाइट पायथन 3 में काम नहीं करता है; यह 2 और 3 दोनों में काम करता है। इसके अलावा, यह एक के बाद एक पोस्ट किया गया था।

— टीएलडब्लू

@ mbomb007 - ठीक है, गोल्फ। यह अब सबसे छोटे पायथन कार्यान्वयन के लिए बंधा हुआ है, और एक बोनस के रूप में यह 2 और 3 दोनों में काम करता है

— 1

1

zsh, 22 बाइट्स

(){echo $1 $_} ${(n)@}

एक लंबो फ़ंक्शन को परिभाषित करता है जो इसके पहले arg ( $1) और पिछले कमांड के अंतिम तर्क ( ) को प्रिंट करता है $_, और इसे $@क्रमबद्ध करने के बाद इसे पास करता है ताकि पिछला कमांड उस लैम्ब्डा का मंगलाचरण बन जाए

zsh, 21 बाइट्स

यह केवल तभी काम करता है जब 1 से अधिक तर्क हो :(

<<<"${${(n)@}/ * / }"

सॉर्ट करता है $@, इसे एक स्ट्रिंग बनाता है और पहले स्थान से अंतिम स्थान तक एक सिंगल स्पेस के साथ सब कुछ बदलता है, फिर इसे बिल्ली के साथ इनपुट के रूप में पास करता है<<<

उपयोग:

$ ./minmax 23 342 21 10
10 342

— izabera
स्रोत

1

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

val s=args.map(_.toInt).sorted
print(s.head+" "+s.last)

निष्पादन हेतु:

$ scala minmax.scala 1 2 3 4 5 6 7 8 9

— AmazingDreams
स्रोत

1

बैश + कोरुटिल्स, 30 बाइट्स

tr \  \\n|sort -n|sed '$p;1!d'

इनपुट के छंटने के बाद, पहले और अंतिम पूर्णांक के बाद सेड स्क्रिप्ट प्रिंट होता है।

— seshoumara
स्रोत

1

डीसी, 110 बाइट्स

?ddsMsmzdsAsa[z1-:az0<S]dsSx[>R]s?[la;asM]sR[lM]sQ[lQxla1-dsa;al?xla0<N]dsNxlAsa[<R]s?[la;asm]sR[lm]sQlNxlmlMf

मेरी मदद करो, dcers! आप मेरी एकमात्र आशा हैं!

उस बग को खोजने के लिए @seshoumara को धन्यवाद!

मैं बाद में एक स्पष्टीकरण जोड़ूंगा। यहाँ यह थोड़ा टूट गया है:

?dd sM sm
zd sA sa
[z 1- :a z0<S]dsSx
 [>R]s?
 [la;asM]sR
 [lM]sQ
[lQx la 1- dsa ;a l?x la0<N]dsNx
lA sa
 [<R]s?
 [la;a sm]sR
 [lm]sQ
lNx
lm lM f

— जो
स्रोत

मैंने रिकॉर्ड नहीं किया कि यह कैसे लागू किया जाए, और अब मुझे याद नहीं है। अब मैं जो कुछ भी कर रहा हूं, वह गलत कर रहा हूं, क्योंकि यह हमेशा 0 सबसे छोटे तत्व के रूप में लौट रहा है।

— जो

1

Pfew! इस पर कुछ अभिनीत हुए, लेकिन आपके कोड में बग पाया गया। यह पहला चरित्र है (0) जिसे आप रजिस्टर करते हैं Mऔर रजिस्टर शुरू करते हैं और m। लेकिन यदि इनपुट सूची में कोई संख्या से छोटी नहीं है m=0, या कोई संख्या से अधिक नहीं है M=0, तो आपको एक गलत परिणाम मिलता है, क्योंकि आपने कृत्रिम रूप से नमूना संख्याओं में 0 जोड़ा है। इसका समाधान उस पहले 0 को बदलना है ?d, जो संख्याओं को पढ़ता है और आरंभ करता है Mऔर mअंतिम संख्या के साथ, इस प्रकार इसे नमूने का एक हिस्सा बनाता है। फिर कोड को इस तरह से चलाएं: "8 _2 5" गूंज। dc -e "; ddsMsm ...."।

— शेषमारा

वाह, धन्यवाद, @seshoumara! मैंने कभी गौर नहीं किया होगा! (मैं इस सवाल के बारे में सब भूल गया, भी: पी)

— जो

1

जावा, 115 बाइट्स

String f(int[]i){int t=i[0],a=t,b=t;for(int c=0;c<i.length;c++){a=i[c]<a?i[c]:a;b=i[c]>b?i[c]:b;}return""+a+" "+b;}

Ungolfed:

String f(int[] i) {
    int t=i[0], a=t, b=t; // assigns a and b to i[0]
    for (int c=0; c < i.length; c++) { // loop through the array
        a=(i[c]<a) ? i[c] : a;
        b=(i[c]>b) ? i[c] : b; // assignment with ternary operator
    }
    return ""+a+" "+b; // returns a string
}

मेरा पहला कभी कोड "गोल्फ" समाधान।

— AMACB
स्रोत

बिना बिल्डिन का उपयोग किए, एक सरणी में न्यूनतम और अधिकतम पूर्णांक प्राप्त करें

चुनौती

उदाहरण सत्र

संदर्भ कार्यान्वयन

नियम

स्पष्टीकरण

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

पायथन, 61 49 37 36 34 31 बाइट्स

ब्रेन-फ्लैक 220 218 बाइट्स

व्याख्या

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

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

आर, 31 बाइट्स

एआरएम मशीन कोड, 26 बाइट्स

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

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

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

05AB1E , 6 4 बाइट्स

MATL , 4 बाइट्स

व्याख्या

पायथन, 29 बाइट्स

सी, 83 81 79 बाइट्स

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

वी , 12 बाइट्स

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

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

PHP, 44 बाइट्स

प्रसंस्करण, 59 52 बाइट्स

पर्ल 6 13 बाइट्स

परीक्षा:

सी #, 60 बाइट्स

POSIX Awk, 44 बाइट्स

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

पायथन, 35 34 बाइट्स

zsh, 22 बाइट्स

zsh, 21 बाइट्स

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

बैश + कोरुटिल्स, 30 बाइट्स

डीसी, 110 बाइट्स

जावा, 115 बाइट्स