पृष्ठभूमि

निम्नानुसार परिभाषित एक अनुक्रम पर विचार करें:

पहला तत्व 0 है;
दूसरा तत्व 4 है;
तीसरे तत्व से, इसके मूल्य की गणना निम्न द्वारा की जा सकती है:
- अनुक्रम के पिछले तत्व तक पूर्णांक के सेट को लेना (समावेशी या अनन्य, यह कोई फर्क नहीं पड़ता);
- किसी भी पूर्णांक को हटाना जो पहले से सेट से अनुक्रम में पहले ही प्रकट हो चुका है;
- सेट के शेष तत्वों को एक साथ जोड़ना; वह मूल्य जो आप चाहते हैं।

दिलचस्प है, यह अनुक्रम अभी तक OEIS पर नहीं लगता है ।

काम

एक प्रोग्राम या फ़ंक्शन लिखें जो एक पूर्णांक n को इनपुट के रूप में लेता है , और अनुक्रम के n वें तत्व को आउटपुट करता है ।

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

अनुक्रम के पहले कुछ तत्व हैं:

0
4
6 (1 + 2 + 3)
11 (1 + 2 + 3 + 5)
45 (1 + 2 + 3 + 5 + 7 + 8 + 9 + 10)
969 (1 + 2 + 3 + 5 + 7… 10 + 12… 44)
468930 (1 + 2 + 3 + 5 + 7… 10 + 12… 44 + 46… 968)

स्पष्टीकरण

यदि आपका भाषा अनियंत्रित रूप से बड़े पूर्णांकों में है और असीमित मात्रा में स्मृति तक पहुँच है, तो आपके कार्यक्रम को सिद्धांत रूप में मनमाने ढंग से n को संभालने में सक्षम होना चाहिए । (बिना बोली के भाषाएं 468930 से आगे निकलने में सक्षम होने की संभावना नहीं है, लेकिन यह उत्तरों को हार्डकोड करने का कोई बहाना नहीं है।)
आप अनुक्रम के लिए या तो 0-आधारित या 1-आधारित अनुक्रमण चुन सकते हैं (जैसे यह आपके ऊपर है कि n = 1 पहला तत्व लौटाता है, n = 2 दूसरा तत्व, और इसी तरह; या क्या n = 0 पहला तत्व लौटाता है ; , एन = 1 दूसरा तत्व, और इसी तरह)।
आपके द्वारा उपयोग किए जाने वाले एल्गोरिथ्म पर कोई आवश्यकता नहीं है, न ही इसकी दक्षता पर; आप सीधे अनुक्रम की परिभाषा को लागू कर सकते हैं (भले ही यह वास्तव में अक्षम है), और आप एक अलग एल्गोरिथ्म को भी लागू कर सकते हैं जो समान परिणाम की ओर ले जाता है।

विजय की स्थिति

यह कोड-गोल्फ है , इसलिए सबसे छोटा सही प्रोग्राम है, जिसे बाइट्स में मापा जाता है, जीतता है।

— ग्रेज़गोरोज़ ओलेदज़की
स्रोत

1

इनपुट लेने के बजाय अनंत आउटपुट की अनुमति क्यों न दें?

— जॉन ड्वोरक

2

@JDDvorak: क्योंकि यह सभी प्रोग्रामों को एल्गोरिदम का उपयोग करने के लिए मजबूर करता है जो हर शब्द को उत्पन्न करता है; प्रश्न लिखने की यह विधि इसे उत्तरदाताओं तक छोड़ती है कि क्या वे ऐसा करना चाहते हैं, या क्या वे एक बंद-फॉर्मूला का उपयोग करना चाहते हैं (यह मानते हुए कि एक है)। इसलिए यह प्रश्न को हल करने में रणनीतियों का अधिक विकल्प देता है।

1

मुझे लगता है कि अनुक्रम वहाँ नहीं है क्योंकि 0,4 एक अजीब ऑफसेट है

— boboquack

1

@boboquack With (0,3), (0,2), (1,4) या इसी तरह की विविधताएं, कुछ शर्तों के बाद अनुक्रम स्थिर रहेगा।

— डेनिस

क्या इसके लिए [गणित] टैग का कोई मतलब है?

— mbomb007

10

जेली , 13 12 9 बाइट्स

rSạo4¥ð@¡

0-आधारित अनुक्रमण का उपयोग करता है।

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

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

rSạo4¥ð@¡  Main link. No arguments. Implicit argument: 0

      ð    Collect everything to the left into a chain and start a new, dyadic one.
           The arity of the first chain is unknown at this point, as it isn't
           prefixed by ø, µ, or ð.
       @   Swap the arguments of the first chain. Swapping  arguments is only
           implemented for dyadic links, so this makes the chain dyadic.
        ¡  Read an integer n from STDIN and execute the chain n times. Taking the
           argument swap into account, the chain is executed first with 0 as left
           and right argument, then with the previous right argument as left
           argument and the previous return value as right argument.
           The return value of the last call is the return value of the quicklink
           and becomes the implicit output.

           Let's call the left argument x and the right argument y.
r            Range; yield [x, ..., y].
 S           Compute the sum of all integers in the range.
     ¥       Convert the two atoms to the left into a dyadic chain, and call that
             chain with arguments x and y.
   o4          Take the logical OR of x and 4, replacing a 0 with 4 and leaving
               positive integers untouched.
  ạ          Take the absolute difference of the sum to the left and the result of
             the logical OR to the right.

— डेनिस
स्रोत

10

पायथन, 66 60 बाइट्स

6 बाइट्स से शेविंग करने के लिए @ डेनिस का धन्यवाद!

f=lambda n:n>2and(f(n-1)-~f(n-2))*(f(n-1)-f(n-2))/2or(5-n)*n

यह अब तक का सबसे गोल्फ टुकड़ा नहीं है, लेकिन यह एक सूत्र का उपयोग करता है जो मैंने बनाया था:

xदायीं ओर जहां है f(n - 1), और yहै f(n - 2)।

स्पष्टीकरण:

से निरंतर पूर्णांकों का योग aकरने के लिए b(सम्मिलित) इस सूत्र द्वारा वर्णित किया जा सकता है:

amount * average

कहाँ amount(संख्याओं की संख्या) इस तरह वर्णित है:

((a - b) - 1)

और average(सभी संख्याओं का औसत) इस तरह वर्णित है:

(a + b) / 2

तो अब पूर्ण सूत्र है:

  ((a - b) - 1)(a + b) / 2
= (a - b - 1)(a + b) / 2

जिस तरह से हम अंतिम सूत्र में यह फार्मूला लागू स्थानापन्न करने के लिए है aके लिए f(n - 1), bके लिए f(n - 2)जो मूल रूप से नई शर्तों के सभी का योग की गणना करता है, और एक अन्य को जोड़ने f(n - 1)(जो अब है a, पर), जो सभी पिछले नियमों का योग है।

इसे एक साथ मिलाकर, हमें मिलता है:

  a + ((a - b - 1)(a + b) / 2)
= a + ((a^2 + ab - ab - b^2 - a - b) / 2)
= a + ((a^2 - b^2 - a - b) / 2)
= (a^2 - b^2 - a - b + 2a) / 2
= (a^2 - b^2 + a - b) / 2
= ((a + b)(a - b) + (a - b)) / 2
= (a + b + 1)(a - b) / 2

के aसाथ xऔर bसाथ में y, और हे presto, आप ऊपर सूत्र के लिए है।

— clismique
स्रोत

9

पायथन 2 , 58 54 50 बाइट्स

r=t=0
exec'r,t=t+r*~-r/2or 4,t-r;'*input()
print r

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

— डेनिस
स्रोत

9

गणितज्ञ, ४ ९ ४ 49 बाइट्स

±2=4;±1=0;±n_:=Tr@Range@±(n-1)-Tr@Array[±#&,n-1]
(* or *)
±2=4;±1=0;±n_:=-Tr@Array[(k=±#)&,n-1]+Tr@Range@k

CP-1252 एन्कोडिंग का उपयोग करता है। कार्य को परिभाषित करता है PlusMinus (±)। 1 अनुक्रमित।

व्याख्या

±2=4;±1=0;±n_:=Tr@Range@±(n-1)-Tr@Array[±#&,n-1]

±2=4;±1=0;                                        (* Define ±1 and ±2 *)
          ±n_:=                                   (* ±n equals ... *)
               Tr@Range@±(n-1)                    (* Sum of (1, 2, ..., ±(n-1)) ... *)
                              -Tr@Array[±#&,n-1]  (* Minus the sum of previous terms *)

— जंगहवान मिन
स्रोत

8

ओएसिस , 11 बाइट्स

कोड:

+>bc-*2/640

स्पष्टीकरण:

F _n के संबंध की कल्पना करने के लिए , आइए f ₅ का उदाहरण लेते हैं । F _{5 की} गणना करने के लिए , आइए निम्नलिखित योग पर एक नज़र डालें:

1 + 2 + 3 + 5 + 7 + 8 + 9 + 10

बोल्ड भाग एफ ₄ के समान ही है । 7 + 8 + 9 + 10 भाग श्रृंखला है [च _n-2 + 1, च _n-1 - 1] । यह सूत्र f _n-1 + Σ [f _n-2 + 1 ... f _n-1 - 1] बनाता है ( वुल्फ्राम लिंक ):

f _n = 0.5 × (f _n-1² - f _n-2² + f _n-1 - f _n-2 )

जिसे फिर से लिखा जा सकता है:

f _n = 0.5 × ((f _n-1 - f _n-2 ) (f _n-1 + f _n-2 ) + (f _n-1 - f _n-2 ))

f _n = 0.5 × ((f _n-1 - f _n-2 ) (f _n-1 + f _n-2 + 1))

यह वह सूत्र है जिसका उपयोग हम कोड में करेंगे:

कोड स्पष्टीकरण

640हिस्सा हमें आधार मामलों देता है:

a(0) = 0
a(1) = 4
a(2) = 6

कोड जो निष्पादित किया जाएगा (जो एक परिभाषित करता है (n) ):

+>bc-*2/

+          # Add a(n + 1) and a(n + 2) implicitly
 >         # Add one to get a(n + 1) + a(n + 2) + 1
  b        # Push a(n + 1)
   c       # Push a(n + 2)
    -      # Subtract from each other
     *     # Multiply with the previous result
      2/   # Halve the result

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

— अदनान
स्रोत

3

स्पष्टीकरण? यह मुझे कई अन्य उत्तरों की तुलना में अधिक उत्सुक है।

@ ais523 मैंने एक स्पष्टीकरण जोड़ा है।

— अदनान

5

जूलिया, ३ ९ ३३ ३२ बाइट्स

!n=n<3?5n-n^2:sum(!(n-2)+1:!~-n)

0-आधारित।

@ डेनिस की बदौलत 6 बाइट बच गईं।

@GlenO के लिए धन्यवाद, एक बाइट को बचाया।

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

पिछला उत्तर 1- आधारित:

!n=n<4?2(n>1)n:sum(!(n-2)+1:!~-n)

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

पिछला असंबद्ध उत्तर 1-आधारित:

f(n)=n<4?n<2?0:n*2:sum(f(n-2)+1:f(n-1))

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

— rahnema1
स्रोत

1

एक अतिरिक्त बाइट को बचाने के लिए, n<3?5n-n^2:इसके बजाय का उपयोग करें n<4?2(n>1)n:- ध्यान दें कि यह 0-आधारित इंडेक्सिंग का उपयोग करने के लिए स्विच करता है, हालांकि।

— ग्लेन ओ

@ गेलो धन्यवाद, 1 बाइट बचाई गई!

— rahnema1

4

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

f=(n,b=4,a=6)=>n?--n?f(n,a,(a+b+1)*(a-b)/2):b:0

पुनरावृत्ति संबंध का उपयोग करता है जो f(n) = sum(range(f(n-2) + 1, f(n-1) + 1))n> 2 के लिए है।

— नील
स्रोत

4

पॉवरशेल , 84 89 88 87 बाइट्स

$OFS='+'
for($a=0,4;$a.Count-le($n="$args")){$a+=("$(1..$a[-1])"|iex)-("$a"|iex)}$a[$n]

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

व्याख्या

0-आधारित अनुक्रमण। केवल के माध्यम से काम करता है n = 6(मेरी विंडोज मशीन पर यह एक ढेर अतिप्रवाह के साथ दुर्घटनाग्रस्त हो जाता है n = 7)।

जंगहवान मिन के उत्तर (पिछली शर्तों की सीमा शून्य राशि का योग) के समान विधि का उपयोग करना ।

पॉवरशेल में एक रेंज / ऐरे को समेटना लंबे समय तक है, इसलिए मैं एक अरेंज में शामिल होने की एक ट्रिक का उपयोग कर रहा हूं ताकि +लॉन्ग एक्सप्रेशन (जैसे 1+2+3+4...etc) बना सकें और फिर इसे iex( Invoke-Expression) के माध्यम से भेज सकें ।

चूंकि मुझे इसे दो बार करने की ज़रूरत है, इसके बजाय -joinमैं विशेष चर सेट कर रहा हूं $OFS, जो आउटपुट फ़ील्ड विभाजक के लिए खड़ा है। जब आप एक सरणी को कड़ा करते हैं, तो यह तत्व तत्वों में शामिल होने के लिए उपयोग किया जाता है; यह एक स्थान के लिए डिफ़ॉल्ट है। इसलिए इसे +(एक बार) सेट करके , मैं इसके $a-join'+'|iexसाथ कुछ बदल सकता हूं "$a"|iex।

एक साधारण forलूप तब तक चलता रहता है जब तक कि अनुक्रम गणना इनपुट पूर्णांक से कम या बराबर नहीं होती है, तब मैं $nवें तत्व को वापस करता हूं ।

— briantist
स्रोत

@AdmBorkBork बहुत अच्छा! मुझे वास्तव में लगता है कि यह एक अलग जवाब के योग्य है; विधि काफी अलग है कि अगर मैं इसे इस्तेमाल करता हूं तो यह मेरे अपने जैसा महसूस नहीं होगा।

— ब्रायंटिस्ट

1

@AdmBorkBork अच्छा, +1, और मैंने उससे एक बात सीखी: लूप के ;बाद की जरूरत नहीं for। इससे पहले कभी महसूस नहीं किया गया था।

— रिश्वतखोर

3

MATL , 17 16 बाइट्स

OKi:"tP:yX-sv]G)

1-बेड इंडेक्सिंग का उपयोग किया जाता है। कोड बहुत अक्षम है। इसके लिए n = 6पहले से ही ऑनलाइन संकलक की मेमोरी सीमा से अधिक है।

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

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

O       % Push 0
K       % Push 4
i       % Input n
:"      % Do the following n times
  t     %   Push a copy of the top array (or number)
  P:    %   Range from 1 to the last element of array
  y     %   Push a copy of the second-top number/array
  X-    %   Set difference
  s     %   Sum
  v     %   Concatenate everything into a column vector
]       % End
G)      % Get n-th entry of the array. Implicity display

के लिए 20 बाइट , निम्न संस्करण स्मृति सीमा से बचा जाता है। लेकिन अभी भी डेटा प्रकार की सीमा है ( doubleप्रकार केवल गारंटी दे सकता है कि पूर्णांकों का सटीक प्रतिनिधित्व किया गया है 2^53), इसलिए परिणाम n = 8केवल तक मान्य हैं ।

OKi:"t0)tQ*2/ys-v]G)

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

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

2

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

f 0=0
f 1=4
f 2=6
f n=sum[1+f(n-2)..f$n-1]

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

यह सीधे पुनरावृत्ति के लिए लागू करता है कि n>2, f(n)के बराबर होती है f(n-1)प्लस से खुला अंतराल का योग f(n-2)करने के लिए f(n-1)जो फिर से आधा खुला अंतराल की राशि के बराबर है f(n-2)करने के लिए f(n-1)समावेशी।

f(0) = 0
f(1) = 4
f(2) = 6 = 1+2+3
f(3) = 11 = 1+2+3+5 = 6 + 5 = 6 + sum]4,6[ = f(2)+ sum]f(1),f(2)[ = sum]f(1),f(2)]
...
f(n) = sum]f(n-2),f(n-1)] = sum[f(n-2)+1,f(n-1)]

— Laikoni
स्रोत

2

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

m#s=m:s#sum[m+1..s]
((0:4#6)!!)

प्रयोग उदाहरण: ((0:4#6)!!) 6-> 468930। इसे ऑनलाइन आज़माएं! ।

सरल पुनरावृत्ति, जो mअब तक अधिकतम तत्व और अगले मूल्य का ट्रैक रखता है s।

— nimi
स्रोत

जब भी मैं एक नई चुनौती के लिए आता हूं, किसी का हमेशा एक हैसेल उत्तर बेहतर होता है, जिससे मैं कभी भी XD कर सकता हूं

— Theonlygusti

मैं हमेशा कुछ मैथ्स चैलेंज पर पहुँचता हूँ, सोचता हूँ "हे अंत में मैं हैस्केल आज़मा सकता हूँ!" सीएमडी-एफ 'हास्केल' - ओह इंतजार करो, यह जवाब ... रुको, क्या? Haskell पर देता है

— theonlygusti

2

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

(a,i=x=y=0)=>{r=[0,4];while(r.length<a){x++;y=0;for(i=0;i<r[x];i++){if(!r.includes(i)){y+=i;}}r.push(y)}return r[a-1];}

इसे ऑनलाइन आज़माएं! यह समाधान, 1-आधारित है f(1) => 0।

— steenbergh
स्रोत

2

पर्ल 6 , 52 49 44 35 बाइट्स

{(|(0,4 X 0),{[+](^.[0])-.[1],.[0]+.[1]}...*)[$_;0]}

कोशिश करो

{(0,(4,0),{[+](^.[0])-.[1],.[0]+.[1]}...*)[$_;0]}

कोशिश करो

{(0,(4,0),{[+](^.[0])-.[1],.sum}...*)[$_;0]}

कोशिश करो

{(0,4,6,{[+] $^a^..$^b}...*)[$_]}

कोशिश करो

विस्तारित:

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

  (
    # generate a sequence

    0, 4, 6,      # seed the sequence

    {             # lambda with placeholder parameters ｢$a｣ ｢$b｣
      [+]         # reduce with ｢&infix:<+>｣
          $^a     # n-2
          ^..     # Range that excludes the first value
          $^b     # n-1
    }
    ...           # keep generating values until
    *             # never stop

  )[ $_ ]         # get the value that was asked for (0 based index)
}

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

2

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

param($n)$a=0,4;1..$n|%{$a+=(0..$a[-1]|?{$_-notin$a})-join'+'|iex};$a[$n]

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

एल्गोरिथ्म को परिभाषित के रूप में लागू करता है, और 0-अनुक्रमित है। 6TIO को संभालने के लिए इनपुट बहुत अधिक है।

$aएक सरणी होने के लिए सेट करता है [0,4]। 1इनपुट से लूप्स $n। लूप में, हम 0हमारे पास सबसे बड़ी संख्या तक की संख्या लेते हैं $a[-1], और केवल उन संख्याओं को बाहर निकालने के लिए एक Where-Objectखंड |?{...}का उपयोग करते हैं जो पहले से मौजूद नहीं हैं। संख्याओं की वह सारणी s के -joinसाथ एक साथ संपादित की जाती है +, और फिर iex(संक्षिप्त Invoke-Expressionऔर इसके समान eval) को खिलाया जाता है । उस मान को तब समाप्त किया जाता है $a। अंत में, हम अपने लूप से बाहर निकलते हैं, और $nहमारे ऐरे नंबर में वें नंबर को लेते हैं । उस नंबर को पाइपलाइन पर छोड़ दिया गया है, और आउटपुट निहित है।

— AdmBorkBork
स्रोत

1

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

def g(n):
 if n<2:return n*4
 s=set(map(g,range(n)));return sum(set(range(max(s)))-s)

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

— OVS
स्रोत

1

बैच, 108 बाइट्स

@if %1==0 echo 0&exit/b
@set/ab=4,a=6
@for /l %%i in (2,1,%1)do @set/ac=(a+b+1)*(a-b)/2,b=a,a=c
@echo %b%

मेरे जावास्क्रिप्ट उत्तर का पोर्ट।

— नील
स्रोत

1

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

?d1-scd/4*dd[d1+*2/r-dsn+dlnlc1-dsc0<x]sxlc0<xp

कंप्यूटर की मेमोरी क्षमता तक पूर्णांक के साथ काम करता है।

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

0-आधारित अनुक्रमण, स्टड पर इनपुट, स्टडआउट पर आउटपुट। (स्टाडर पर आउटपुट भी है, जिसे अनदेखा करना है।)

नमूना चलता है:

$ for ((j=0;j<12;j++)){ echo -n "$j ";dc -f sumseq.dc <<<"$j";echo;} 2>/dev/null
0 0

1 4

2 6

3 11

4 45

5 969

6 468930

7 109947436950

8 6044219445882138462810

9 18266294354989892462984673364511343859409730

10 166828754731567805766174036610844675771635260155825966927845486666328\
837158267993261860

11 139159167026428037700805570917048711514125048327321592278500415852500\
422178720517080334552793040951056255170819719745908378102737875659900\
61575545777065220385544711322919415

यह बैश में निम्नलिखित समाधान के रूप में एक ही एल्गोरिथ्म का उपयोग करता है, जो (थोड़ा) अधिक पठनीय है:

शुद्ध बैश, 60 बाइट्स

for((n=s=$1?4:0,k=1;k<$1;k++,s+=(n=n++*n/2-s))){ :;}
echo $n

लेकिन बैश प्रोग्राम केवल 7 तक के इनपुट के लिए काम करता है, क्योंकि यह पूर्णांक से अधिक ओवरफ्लो को हिट करता है।

— मिशेल स्पेक्टर
स्रोत

0

पायथ - 15 बाइट्स

ePu+Gs-UeGGQ,Z4

टेस्ट सूट ।

— Maltysen
स्रोत

0

सी # - 74 बाइट्स

int A(int f){int e=4,i=1,s=0;for(;i++<f;)e=e*-~e/2-(s+=e);return f>0?e:0;}

Ungolfed:

int A(int f)
{
    int e = 4, 
        i = 1, 
        s = 0; // e is the last element, s is the sum of all previous elements
    for (; i++ < f; ) // calculate for indexes 1 through max (don't need the index, just a correct number of loop cycles)
        e = e * -~e / 2 - (s += e); // -~e => (e + 1), higher precedence to remove parentheses
    return f > 0 ? e : 0; //handle input 0 as a special case, which is 0
}

संभवत: और भी कुछ बचाने के लिए इसे लैम्ब्डा में बदलने का एक तरीका है। या कुछ भी। हालाँकि वर्तमान में मेरा कोई आयात नहीं है, इसलिए शायद यह स्पष्ट हो गया है?

— ब्रायन जे
स्रोत

0

> <> , 43 + 3 = 46 बाइट्स

अदनान और Qwerp-Derp के उत्तरों में प्रस्तुत सूत्र का उपयोग करता है।

:2(?^&46v
}v?=&:&l<,2*{-$@:}+1+@:{::
*>n;>4

स्टैक पर मौजूद इनपुट की अपेक्षा करता है, इसलिए -vध्वज के लिए +3 बाइट्स ।

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

— सोक
स्रोत

पूर्णांक के योगों का एक क्रम जो अनुक्रम में नहीं है

पृष्ठभूमि

काम

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

स्पष्टीकरण

विजय की स्थिति

जेली , 13 12 9 बाइट्स

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

पायथन, 66 60 बाइट्स

स्पष्टीकरण:

पायथन 2 , 58 54 50 बाइट्स

गणितज्ञ, ४ ९ ४ 49 बाइट्स

व्याख्या

ओएसिस , 11 बाइट्स

कोड:

स्पष्टीकरण:

कोड स्पष्टीकरण

जूलिया, ३ ९ ३३ ३२ बाइट्स

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

पॉवरशेल , 84 89 88 87 बाइट्स

व्याख्या

MATL , 17 16 बाइट्स

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

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

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

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

पर्ल 6 , 52 49 44 35 बाइट्स

विस्तारित:

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

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

बैच, 108 बाइट्स

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

शुद्ध बैश, 60 बाइट्स

पायथ - 15 बाइट्स

सी # - 74 बाइट्स

> <> , 43 + 3 = 46 बाइट्स