चुनौती का वर्णन

एक अनुक्रम का "विचलन" एक क्रमचय है जहां कोई तत्व अपनी मूल स्थिति में प्रकट नहीं होता है। उदाहरण के लिए ECABDएक अपमान है ABCDE, लेकिन CBEDAयह नहीं है:

ABCDE
 | |   <- B and D are in their orignal positions
CBEDA

एक अनुक्रम को देखते हुए, इसका एक यादृच्छिक व्युत्पन्न उत्पन्न करें।

आप या तो इनपुट के रूप में एक स्ट्रिंग या तत्वों की एक सूची / सूची (पूर्णांक, वर्ण, ऑब्जेक्ट ...) ले सकते हैं
एक नई वस्तु वापस करने के बजाय, आप किसी मौजूदा को उसके तत्वों को स्वैप करके संशोधित कर सकते हैं
प्रत्येक व्युत्पत्ति में उत्पन्न होने की समान संभावना होनी चाहिए
आप मान सकते हैं कि अनुक्रम में एक से अधिक तत्व हैं और कोई भी एक से अधिक बार दिखाई नहीं देता है

— shooqie
स्रोत

4

सम्बंधित?

— Addison Crump

3

@VoteToClose: हाहा, पूरी तरह से पर्दाफाश

— शौकी

मुझे इस सब के बारे में ज्यादा जानकारी नहीं है लेकिन क्या यह किसी भी तरह से तय बिंदु प्रमेय से संबंधित है ... जिसके अनुसार चीजें हमेशा अपनी स्थिति में रहेंगी या ऐसा कुछ होगा ...? मैं दांव लगाऊंगा मैं गलत हूं, लेकिन कोई मुझे सही करे :)

— फरहान अनम

क्या कोई गारंटी है कि तत्व अद्वितीय होंगे, या क्या उनमें डुप्लिकेट हो सकते हैं?

— कैरिजनेट

1

@Carcigenicate: यह विवरण में वहीं है; आप मान सकते हैं कि कोई डुप्लिकेट नहीं हैं

— shooqie

12

CJam , 14 बाइट्स

q:X{mr_X.=:|}g

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

यह एक विचलन है जब तक इनपुट फेरबदल रहता है।

व्याख्या

q:X   e# Read input and store it in X.
{     e# While the condition at the end of the loop is truthy...
  mr  e#   Shuffle the string.
  _X  e#   Duplicate it and push the input.
  .=  e#   Element-wise equality check.
  :|  e#   Reduce OR over the list, gives something truthy if any character
      e#   remained in its original position.
}g

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

1

काश ओपी ने निर्दिष्ट किया होता कि समाधानों की गारंटी उन्हें हमेशा खत्म करनी होती।

— जॉन ड्वोरक

4

@JDDvorak खैर, संभावना है कि यह खत्म नहीं होता है 0. लेकिन आप सही कह रहे हैं कि एक नियतात्मक चल रहे समय की आवश्यकता है चुनौती को और अधिक रोचक बना देगा।

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

क्या वास्तव में संभावना 0 है? फेरबदल ऑपरेशन सही नहीं होगा, यह वास्तव में कैसे काम करता है? मुझे लगता है कि यह संभवतः एक अच्छा अनुमान है कि ओपी ने क्या पूछा था, लेकिन मुझे संदेह है कि प्रत्येक अपमान की संभावनाएं समान हैं (शायद यह PRNG के कुछ बीज मूल्य पर निर्भर करता है जो संभवतः फेरबदल ऑपरेशन द्वारा उपयोग किया जाता है)।

— कोई नहीं

3

@ कोई नहीं मुझे संदेह है कि आप किसी भी एल्गोरिथ्म का उपयोग करके PRNG से पूरी तरह से समान परिणाम प्राप्त कर सकते हैं । हालांकि, यह मानते हुए कि फेरबदल एक समान है (जो कि जावा डॉक्स गारंटी के साथ "सभी क्रमपरिवर्तन लगभग समान संभावना के साथ होते हैं"), अस्वीकृति-आधारित समाधान भी एक समान उपहास पैदा करेगा, क्योंकि प्रत्येक व्युत्पत्ति एक क्रमपरिवर्तन है, और प्रत्येक क्रमचय में एक ही संभावना है।

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

1

@ कोई भी मठ यहाँ नहीं है। ऐसी स्थिति जो या तो सफल होती है या विफल होती है, उसे आंकड़ों में बर्नौली परीक्षण कहा जाता है। इसका तात्पर्य यह है कि पहली सफलता के लिए k k के परीक्षण की संभावना (1 - p) ^ (k - 1) * p है, जहाँ p एक सफल विचलन की संभावना है। यह देखना आसान है कि जैसे-जैसे k बड़ा होता है, k परीक्षणों की आवश्यकता की संभावना गायब होती जाती है। इसलिए, हम कहते हैं कि एल्गोरिथ्म संभावना 1 ("लगभग निश्चित रूप से") के साथ रुकता है, फिर भी यह असंभव नहीं है कि यह कभी नहीं रुकता है।

— मासवाच

9

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

Ẋ=³S$¿

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

व्याख्या

Ẋ    ¿    Shuffle the given list while this is nonzero for it:
    $       A two-step process:
 =³           Element-wise equality of it and L (the original list)...
   S          Sum the ones in this binary array.

जोनाथन एलन ने एक बाइट को बचाया।

— लिन
स्रोत

5

तो आप समय से पहले अपने शीतकालीन बैश टोपी मिल गया? :-)

— लुइस मेंडो

2

एक अच्छी नई तस्वीर खींचने का समय, Ẋ=³S$¿एक बाइट बचाता है।

— जोनाथन एलन

2

हुह, मुझे इसके बारे में कभी नहीं पता था $। धन्यवाद!

— लिन

यह 6 वर्ण है, लेकिन 6 से अधिक बाइट्स हैं। Ẋ = ¿S $ te बाइट लंबाई हैं: 312112. तो कुल 10 बाइट्स।

— mxfh

6

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

इसमें दी गई सूची को संशोधित करता है (मेटा द्वारा और प्रश्न में अनुमति दी गई है)।

from random import*
def D(l):
 o=l[:]
 while any(x==y for x,y in zip(o,l)):shuffle(l)

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

— FlipTack
स्रोत

1

यदि आप पायथन 2 निर्दिष्ट करते हैं, तो मुझे लगता है कि आप के def D(l):साथ प्रतिस्थापित कर सकते हैं l=input()और फिर निम्नलिखित लाइनों में इंडेंटेशन रिक्त स्थान को बचा सकते हैं (इसलिए आपके पास एक फ़ंक्शन के बजाय एक कार्यक्रम है)। हालांकि, गिरावट नहीं हुई!

— मैथमेटंदन

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

— फ्लिपकार्ट

1

ठीक है तुम कहते हो तो। मुझे लगता है कि कल्पना यह कह रही थी कि आपको इसका प्रिंट आउट निकालने या वापस करने की ज़रूरत नहीं थी - जो कि एक सूची [उपयोगकर्ता इनपुट] से लेना और उसे फेरबदल करना पर्याप्त होगा। लेकिन "मौजूदा" को "आपके किसी भी कोड को चलाने से पहले मौजूदा" के रूप में पढ़ना उचित है, जिस स्थिति में मैं आपसे सहमत हूं। (हो सकता है कि इस पर एक सर्वसम्मति से सहमति बनी हो।) :)

— मैथमेटंदन

5

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

इनपुट और आउटपुट सरणियां हैं, किसी भी प्रकार के तत्वों (तार, संख्या आदि) के साथ काम करना चाहिए, जब तक कि उनकी तुलना "=" के साथ की जा सकती है।

golfed

F=s=>(r=[...s]).sort(_=>Math.random()-.5).some((e,i)=>s[i]==e)?F(s):r

परीक्षा

F=s=>(r=[...s]).sort(_=>Math.random()-.5).some((e,i)=>s[i]==e)?F(s):r

F(['A','B','C','D'])
Array [ "D", "C", "A", "B" ]

F(['A','B','C','D'])
Array [ "D", "A", "B", "C" ]

F(['A','B','C','D'])
Array [ "C", "D", "B", "A" ]

F(['A','B','C','D'])
Array [ "D", "C", "B", "A" ]

F(['A','B','C','D'])
Array [ "C", "D", "B", "A" ]

इंटरएक्टिव स्निपेट

F=s=>(r=[...s]).sort(_=>Math.random()-.5).some((e,i)=>s[i]==e)?F(s):r

function G() {
    console.log(F(T.value.split``).join``); 
}

<input id=T value="ABCDEF"><button id=G onclick="G()">GENERATE</button>

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

— टसेपेल्लिन
स्रोत

5

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

{first (*Zne$_).all,.pick(*)xx *}

एक लैम्ब्डा जो पूर्णांक या वर्णों की सूची को इनपुट के रूप में लेता है, और एक नई सूची देता है।

यदि इसे मनमाने मूल्यों की सूचियों का समर्थन करना चाहिए, तो इसे (+2 बाइट्स) के neसाथ !eqvबदलना होगा।

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

स्पष्टीकरण:

{ }: एक मेमने को परिभाषित करता है।
.pick(*): इनपुट सूची का एक यादृच्छिक फेरबदल उत्पन्न करता है।
.pick(*) xx *: इस तरह के फेरबदल का एक आलसी अनंत अनुक्रम बनाता है।
(* Zne $_).all: एक लैम्ब्डा जो (नकारात्मक स्ट्रिंग समानता) ऑपरेटर के साथ दो सूचियों (इसके तर्क *, और बाहरी लैम्ब्डा के तर्क $_) neको जिप करता है, बूलियन्स की एक सूची की उपज देता है, और फिर उन्हें एक एकल बंजर राज्य में ढहने के लिए एक allजंक्शन बनाता है ।
first PREDICATE, SEQUENCE: क्रमबद्धता के हमारे अनंत अनुक्रम से पहला तत्व लेता है जो "अपमान" परीक्षण को पूरा करता है।

— SMLS
स्रोत

4

ब्रेकीलॉग , 19 18 15 13 बाइट्स

@~.:?z:#da;?&

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

व्याख्या

@~.                Output is a shuffle of the input
  .:?z             Zip the output with the input
      :#da         All couples of integers of the zip must be different
          ;      Or
           ?&      Call recursively this predicate with the same input

— Fatalize
स्रोत

3

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

{(@^a,{[.pick(*)]}...{none @a Zeqv@$_})[*-1]}

{(@^a,{[.pick(*)]}...{!sum @a Zeqv@$_})[*-1]}

कोशिश करो

इनपुट किसी भी चीज़ का एक ऐरे है।

विस्तारित:

{
  (

    @^a,          # declare parameter, and seed sequence generator

    {             # lambda with implicit parameter ｢$_｣
      [           # store into an array
        .pick(*)  # shuffle ｢$_｣
      ]
    }

    ...           # keep generating the sequence until

    {
      none        # none
      @a          # of the outer blocks input
      Z[eqv]      # is zip equivalent
      @$_         # with the current value being tested
    }

  )[ * - 1 ]      # return the last value
}

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

3

MATL, 7 बाइट्स

यह मेरी ऑक्टेव पोस्ट का अनुवाद है (और कुछ अन्य प्रस्तुतियाँ के समान)। मैंने अपनी पहली MATL पोस्ट कल (CNR क्रैक) पोस्ट की, तो मुझे लगता है कि यह इष्टतम नहीं है, लेकिन यह सबसे अच्छा है जो मैंने अब तक प्राप्त किया है।

सच कहूं, तो मुझे पूरी तरह से यकीन नहीं है कि tइसमें जरूरत है, लेकिन यह एकमात्र तरीका है जिससे मुझे यह काम मिल सकता है। इसका उपयोग इसलिए किया जाता है ताकि मैं उपयोगकर्ता इनपुट (साथ पुनर्प्राप्त) की तुलना कर सकूंG यादृच्छिक क्रमचय के साथ ) की । मुझे लगता है कि मैं इसके बिना दोनों की तुलना कर सकता हूं, लेकिन ...?

वैसे भी, यहाँ जाता है:

`Z@tG=a

`          % Loop
 Z@        % Random permutation of input
   t       % Duplicating the stack
    G      % Paste from clipboard G (user input)
     =     % Comparing the random permutation with the input (retrieved from clipboard)
      a    % any(input == random permutation)
           % Implicit end and display

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

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

कोई सुधार? क्या मुझे वास्तव में tवहां जरूरत है या क्या मैं इससे छुटकारा पा सकता हूं? यह MATL में गोल्फ की कोशिश में मजेदार था ... :)

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

:-) मुझे नहीं पता कि इससे कैसे छुटकारा पाया जाए t(या समकक्ष रूप से G) आपको अगले पुनरावृत्ति के लिए या अंतिम परिणाम के रूप में स्टैक पर कुछ छोड़ने की आवश्यकता है

— लुइस मेंडू

3

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

;;WX╚│♀=ΣWX)X

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

स्पष्टीकरण:

;;WX╚│♀=ΣWX)X
;;             make two copies of input
  WX╚│♀=ΣW     while top of stack is truthy:
   X             discard top of stack
    ╚            shuffle array
     │           duplicate entire stack
      ♀=         compare corresponding elements in shuffled and original for equality
        Σ        sum (truthy if any elements are in the same position, else falsey)
          X)X  discard everything but the derangement

— मेगो
स्रोत

2

ऑक्टेव, 56 55 बाइट्स

x=input('');while any(x==(y=x(randperm(nnz(x)))));end,y

हमें इसका उपयोग करना है input('')क्योंकि यह एक फ़ंक्शन नहीं है। इसके अलावा, चूंकि मैं एक स्ट्रिंग के रूप में इनपुट का चयन कर सकता हूं, हम उस ट्रिक का उपयोग कर सकते हैं जो nnz(x)==numel(x)।

स्पष्टीकरण:

x=input('')            % Self-explanatory
while any(x==y)        % Loop until x==y has only 0s (i.e. no elements are equal)
y=x(randperm(nnz(x)))  % Continue to shuffle the indices and assign x(indices) to y
end                    % End loop
y                      % Display y

लुइस को धन्यवाद देने के लिए कि इनपुट एक स्ट्रिंग हो सकता है, इस प्रकार मैं दो बाइट बचाने के nnzबजाय उपयोग कर सकता हूं numel।

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

स्वयं पर ध्यान दें: अगली बार पूरा प्रश्न पढ़ें :) धन्यवाद!

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

1

यह मेरे लिए हर समय होता है :-)

— लुइस मेंडो

2

MATL, 13 बाइट्स

यह @LuisMendo और मेरे का एक संयुक्त प्रयास है। यहाँ कई अन्य उत्तरों के विपरीत यह एक अर्थ में नियतात्मक है कि यह तब तक यादृच्छिक क्रमपरिवर्तन का नमूना नहीं लेता है जब तक कि यह एक विच्छेद नहीं मिलता है, लेकिन यह सभी व्युत्पन्नता उत्पन्न करता है और एक यादृच्छिक रूप से चुनता है।

Y@tG-!Af1ZrY)

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

व्याख्या

Y@tG-!Af1ZrY)
Y@             generate all permutatoins
  t            create a duplicate
   G-!A        find the (logical) indices of all valid derangements (where no character of the string is in the same position as the original string)
       f       convert logical to linear indices
        1Zr    choose one of those indices randomly
           Y)  get the derangement (from the ones we generated earlier) at this index

— flawr
स्रोत

2

अजगर - 10 9 बाइट्स

यह इनपुट में फेरबदल करता रहता है, जबकि कोई भी वर्ण इनपुट में अपने सूचकांक में वर्णों के बराबर होता है।

.WsqVHQ.S

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

.W           Iterate while
 s           Sum, this is works as any() on a boolean list
  qV         Vectorized equality
   H         The lambda variable for the check step
   Q         The input
 .S          Shuffle
  (Z)        Lambda variable, implicit
 (Q)         Start .W with input, implicit

— Maltysen
स्रोत

क्या आप कृपया स्पष्टीकरण जोड़ सकते हैं। मैं एक अजगर जवाब लिखना चाहता था। मैं इसके बारे में ज्यादा नहीं जानता।

— गुरुपद ममदापुर

@GurupadMamadapur ज़रूर, खुश भी होंगे।

— माल्टीसेन

1

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

— माल्टीसेन

2

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

#/.x_:>RandomChoice@Select[Permutations@x,FreeQ[#-x,0]&]&

एक सूची के रूप में whatevers की एक सूची लेने और एक सूची outputting समारोह। #इनपुट के सभी क्रमपरिवर्तन को उत्पन्न करने के बाद x, हम केवल उन्हीं को रखते हैं जिनके लिए #-xतत्व-वार अंतरों के सेट में ए नहीं है 0; फिर हम उस सेट से एक (समान) यादृच्छिक विकल्प बनाते हैं।

— ग्रेग मार्टिन
स्रोत

1

अच्छा! थोड़ा लंबा #/.x_:>NestWhile[RandomSample[#,Length@#]&,#,Not@FreeQ[#-x,0]&]&स्पष्ट रूप से तेज लंबे तार के लिए व्यवहार में

— मार्टिन

रुको, आप मुझे बता रहे हैं कि मैथेमेटिका में अपमान के लिए कोई बिल्ट-इन नहीं है? : ओ

— शुकी डे

मैं आधे से खुद में एक उम्मीद कर रहा था :)

— ग्रेग मार्टिन

0

PHP, 85 बाइट्स

for($a=$b=str_split($argv[1]);array_diff_assoc($a,$b)!=$a;)shuffle($b);echo join($b);

स्ट्रिंग तर्क को दो सरणियों में कॉपी करता है, उनमें से एक को तब तक फेरबदल करता है जब तक कि उनके बीच का अंतर (तत्वों की अनुक्रमणिका की तुलना करना) दूसरे के बराबर न हो जाए। साथ चलाना -r।

— टाइटस
स्रोत

0

आर, 59 बाइट्स

z=x=1:length(y<-scan(,""));while(any(x==z))z=sample(x);y[z]

एसटीडीआईएन को तत्वों की एक सूची पढ़ता है, सूची की लंबाई लेता है और 1 से लंबाई तक नमूने लेना शुरू करता है, जब तक कि यह एक ऐसा नहीं मिलता है जो आदेशित सूची के साथ कोई स्थान साझा नहीं करता है। फिर उस सूची को प्रिंट करता है।

— JAD
स्रोत

0

वंडर , 32 बाइट्स

f\@[/>#I zip#=[#0a\shuf#0]?f a?a

उपयोग:

f\@[/>#I zip#=[#0a\shuf#0]?f a?a];f[1 2 3 4 5]

व्याख्या

अधिक पठनीय:

f\@[
  some #I zip #= [#0; a\ shuf #0]
    ? f a
    ? a
]

पुनरावर्ती कार्य f। एक तत्व-वार fइनपुट सूची और इनपुट सूची के फेरबदल संस्करण के बीच तुलना करता है । यदि तुलना किसी भी समान मूल्यों की पैदावार करती है, तो fउसे फेरबदल सूची में कहा जाता है। अन्यथा, हम बस फेरबदल सूची वापस करते हैं।

— मामा फन रोल
स्रोत

0

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

def f a
while (a.zip(o=a.shuffle).map{|x,y|x-y}.index 0);end
o
end

— DepressedDaniel
स्रोत

0

ऑक्टेव, 54 53 बाइट्स

@(a)((p=perms(a))(L=!any(p==a,2),:))(randi(sum(L)),:)

के सभी क्रमपरिवर्तन उत्पन्न aकरें और बेतरतीब ढंग से एक पंक्ति चुनें जिसमें एक सामान्य तत्व नहीं हैa ।

नोट: यह गलती से @flawr MATL उत्तर के समान है!

— rahnema1
स्रोत

0

क्लोजर, 94 90 79 बाइट्स

#(let[s(shuffle %)](if(not(some(fn[[x y]](= x y))(map vector % s)))s(recur %)))

-4 बाइट्स में कमी and, और इनलाइनिंग के अंदर सशर्त को बदलकरdone? ।

-11 बाइट्स में कटौती को परिवर्तित करके some।

यहाँ प्रारंभ करें PHP को हराया।

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

Ungolfed:

(defn dearang [ls]
  (let [s (shuffle ls)
        bad? (some (fn [[x y]] (= x y))
                (map vector ls s))]
    (if (not bad?) s (recur ls))))

— Carcigenicate
स्रोत

0

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

#(let[s(shuffle %)](if((set(map = % s))true)(recur %)s))

ध्यान दें कि एक स्ट्रिंग को फेरबदल नहीं किया जा सकता है, के माध्यम से पारित किया जाना चाहिए seqया vec।

मूल रूप से मैंने कोशिश की #(first(remove(fn[s]((set(map = % s))true))(iterate shuffle %)))लेकिन recurदृष्टिकोण वास्तव में से कम हैiterate ।

जादू यह है कि (set(map = % s))झूठ का एक सेट, सच्चे का सेट या सच्चे और झूठ का सेट होता है। यह एक फ़ंक्शन के रूप में इस्तेमाल किया जा सकता है, अगर इसमें शामिल है trueतो जवाब है true, अन्यथा मिथ्या है nil। =दो इनपुट तर्क लेने में प्रसन्नता है, इसे किसी चीज़ के साथ लपेटने की आवश्यकता नहीं है।

((set [false]) true)
nil

हो सकता है कि यह जाँचने का कोई छोटा तरीका हो कि क्या कोई मान सत्य है?

— NikoNyrh
स्रोत

0

एपीएल, 11 बाइट्स।

सही तर्क में स्ट्रिंग के साथ:

⍵[⍋(⍴⍵)?⍴⍵]

व्याख्या

ρ⍵ सही तर्क की लंबाई (या आकार) प्राप्त करता है।

?(⍴⍵)इन नंबरों की एक यादृच्छिक सरणी देता है ।

⍋ कोई डुप्लिकेट सुनिश्चित करने के लिए उनमें से आदेश देता है।

⍵[..] इस सूचकांक का उपयोग करके स्ट्रिंग के यादृच्छिक वर्गीकरण का प्रतिनिधित्व करता है।

— जैकब यूटली
स्रोत

PPCG में आपका स्वागत है! हमें सभी प्रविष्टियों को मान्य फ़ंक्शन या पूर्ण कार्यक्रम होने की आवश्यकता है, इसलिए आपके उत्तर को फ़ंक्शन तर्क या इनपुट विधि के माध्यम से इनपुट लेना होगा।

— ETHproductions 16

मुझे लगता है कि अब इसे आवश्यकताओं को पूरा करना चाहिए। यह सही तर्क में है, या ⍵।

— याकूब यूटली

एक यादृच्छिक व्युत्पन्न उत्पन्न करें

चुनौती का वर्णन

टिप्पणियाँ

CJam , 14 बाइट्स

व्याख्या

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

व्याख्या

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

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

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

स्पष्टीकरण:

ब्रेकीलॉग , 19 18 15 13 बाइट्स

व्याख्या

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

विस्तारित:

MATL, 7 बाइट्स

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

ऑक्टेव, 56 55 बाइट्स

MATL, 13 बाइट्स

व्याख्या

अजगर - 10 9 बाइट्स

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

PHP, 85 बाइट्स

आर, 59 बाइट्स

वंडर , 32 बाइट्स

व्याख्या

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

ऑक्टेव, 54 53 बाइट्स

क्लोजर, 94 90 79 बाइट्स

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

एपीएल, 11 बाइट्स।

व्याख्या