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

दूसरे शब्दों में, इनपुट के प्रत्येक उपसर्ग के लिए दूसरा सबसे बड़ा मूल्य आउटपुट।

आप पहले तत्व (जहां k = 1) के लिए एक मनमाना मूल्य आउटपुट कर सकते हैं , या बस इस मूल्य को छोड़ सकते हैं, क्योंकि 1 तत्व की सूची के लिए दूसरा अधिकतम नहीं है। आप मान सकते हैं कि इनपुट में कम से कम 2 तत्व हैं।

सबसे छोटा कोड जीतता है।

उदाहरण

Input:
1 5 2 3 5 9 5 8
Output:
  1 2 3 5 5 5 8
Input:
1 1 2 2 3 3 4
Output:
  1 1 2 2 3 3
Input:
2 1 0 -1 0 1 2
Output:
  1 1 1 1 1 2

code-golf number array-manipulation

— jimmy23013
स्रोत

मेरी अंग्रेजी सबसे अच्छी नहीं है, यह कैसे kनिर्धारित किया जाता है?

— LiefdeWen

@LiefdeWen प्रत्येक k के उत्तर वाली सूची को आउटपुट करता है।

— jimmy23013

2

1यह नहीं है, कड़ाई से बोल रहा है, (दूसरा उदाहरण) का दूसरा सबसे बड़ा मूल्य है 1,1जब यह अवरोही क्रमबद्ध होता है।

— जोनाथन एलन

शायद मैं सिर्फ बेवकूफ हूं (हालांकि मुझे संदेह है कि मैं वास्तव में सप्ताहांत शुरू कर सकता था ..), लेकिन मुझे अभी भी यकीन नहीं है कि यह कैसे काम करता है। क्या कोई ELI5 मेरे लिए आखिरी टेस्ट केस हो सकता है? पहले दो परीक्षण मामलों को मैं सूची में केवल लूपिंग द्वारा हल कर सकता हूं, सूची के वर्तमान न्यूनतम को निर्धारित करता हूं, और फिर उस आइटम को हटा दें (या आसान: सूची को सॉर्ट करें और अंतिम आइटम को हटा दें)। यह पहले दो परीक्षण मामलों के लिए सही परिणाम देता है, लेकिन स्पष्ट रूप से गलत है (और -1, 0, 0, 1, 1, 2आखिरी परीक्षण के मामले के लिए दे देंगे ।)

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

1

@KevinCruijssen दो सबसे बड़ी संख्या याद रखें जो आपने देखी हैं। अंतिम स्थिति में, आप 2 सबसे बड़े होने के साथ शुरू करते हैं, और कुछ भी आउटपुट नहीं करते हैं / जो भी इस बिंदु पर समझ में नहीं आता है। फिर आप अगले पुनरावृत्ति पर 1 और 2 में बदल जाते हैं, इसलिए आप 1. आउटपुट करते हैं। यह तब तक रहता है जब तक आप अंत में 2 तक नहीं पहुंच जाते, और तब आपके पास 2 और 2 सबसे बड़े और दूसरे सबसे बड़े होते हैं

— FryAmTheEggman

6

05AB1E , 5 बाइट्स

ηεà\à

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

[]पहले के लिए रिटर्न (मनमाना मूल्य)।

— आउटग्रॉफर को एरिक करें
स्रोत

η¦ε{¨θ6 बाइट्स के लिए काम करना चाहिए

— अदनान

@ Adnan बेशक> _ <वैसे भी एक बेहतर तरीका पाया ...

— एरिक द आउटगलर

दिलचस्प ... Z©KZ®‚¹sÃमैं क्या सोच रहा था, यह भी नहीं पता àथा कि एक बात है!

— मैजिक ऑक्टोपस Urn

एक और 5-बाइट विकल्प मिला । मैं Áθइसके बजाय इस्तेमाल किया।

— श्री एक्सकोडर

5

भूसी , ९ by बाइट्स

@Zgarb को एक बाइट या दो धन्यवाद दिया

mȯ→hOtḣ

0पहले "दूसरे अधिकतम" के लिए रिटर्न

explaination

         -- implicit input, e.g          [1,5,3,6]
      ḣ  -- prefixes                     [[],[1],[1,5],[1,5,3],[1,5,3,6]]
     t   -- remove the first element     [[1],[1,5],[1,5,3],[1,5,3,6]]
mȯ       -- map the composition of 3 functions
    O    --   sort                       [[1],[1,5],[1,3,5],[1,3,5,6]]
   h     --   drop the last element      [[],[1],[1,3],[1,3,5]
  →      --   return the last element    [0,1,3,5]
         -- implicit output

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

— H.PWiz
स्रोत

1

आप →hOइसके बजाय नक्शा कर सकते हैं और एक बाइट बचा सकते हैं ।

— ज़गर्ब

4

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

lambda x:[sorted(x[:i])[-2]for i in range(2,1+len(x))]

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

— छड़ी
स्रोत

3

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

@Neil को 1 बाइट धन्यवाद दिया

संलग्न कर देता है undefinedके लिए k = 1 ।

a=>a.map(e=>(b=[e,...b]).sort((a,b)=>b-a)[1],b=[])

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

NB: यह स्निपेट JSON.stringify()पठनीयता के लिए उपयोग करता है, जो - एक साइड इफेक्ट के रूप में - में कनवर्ट करता undefinedहै null।

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

let f =

a=>a.map(e=>(b=[e,...b]).sort((a,b)=>b-a)[1],b=[])

console.log(JSON.stringify(f([1, 5, 2, 3, 5, 9, 5, 8]))) // 1 2 3 5 5 5 8
console.log(JSON.stringify(f([1, 1, 2, 2, 3, 3, 4])))    // 1 1 2 2 3 3
console.log(JSON.stringify(f([2, 1, 0, -1, 0, 1, 2])))   // 1 1 1 1 1 2

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

— Arnauld
स्रोत

1

मुझे लगता a=>a.map(e=>(b=[e,...b]).sort((a,b)=>b-a)[1],b=[])है कि केवल 50 है।

— नील

@ नील अच्छा लगा। :-)

— अरनौलड

2

पायथ , 8 बाइट्स

m@Sd_2._

इसे ऑनलाइन आज़माएं! या टेस्ट सूट की कोशिश करो!

कैसे?

यह सूची के पहले तत्व को सूची में पहले मूल्य के रूप में आउटपुट करता है , कल्पना के अनुसार आप पहले तत्व के लिए एक मनमाना मूल्य का उत्पादन कर सकते हैं ।

m@Sd_2._ - निहित इनपुट के साथ पूर्ण कार्यक्रम।

m ._Q - एक चर d के साथ इनपुट के उपसर्गों पर नक्शा।
  एसडी - वर्तमान उपसर्ग को सॉर्ट करता है।
 @ - तत्व हो जाता है ...
    _2 - सूचकांक में - 2 (दूसरा उच्चतम)।
           - स्पष्ट रूप से प्रिंट करें।

— श्री Xcoder
स्रोत

2

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

ḣJṢ€Ṗ€Ṫ€

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

पहला मान 0, हमेशा होगा, और निम्नलिखित संख्या प्रत्येक उपसर्ग का दूसरा अधिकतम होगा।

व्याख्या

ḣJṢ€Ṗ€Ṫ€  Input: array A
 J        Enumerate indices, [1, 2, ..., len(A)]
ḣ         Head, get that many values from the start for each, forms the prefixes
  Ṣ€      Sort each
    Ṗ€    Pop each, removes the maximum
      Ṫ€  Tail each

— मील की दूरी पर
स्रोत

@ चैलेंजर 5 मुझे विश्वास नहीं है कि काम करता है

— मील

@ चैलेंजर 5 जो काम नहीं करता है ...

— आउटगोल्फर

@EriktheOutgolfer ओह, ठीक है।

— फलों के

2

जावा (ओपनजेडके 8) , 87 86 बाइट्स

a->{int x,y=x=1<<-1;for(int c:a){if((c>x?x=c:c)>y){x=y;y=c;}System.out.print(x+" ");}}

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

— Nevay
स्रोत

के लिए +1 int x,y=x=। मुझे पता नहीं था कि एक ही बयान में अलग-अलग घोषणा और असाइनमेंट किया जा सकता है।

— जैकब

2

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

f=lambda l:l[1:]and f(l[:-1])+[sorted(l)[-2]]

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

कोड का दाईं ओर स्व-व्याख्यात्मक है। हालाँकि, हम बाईं ओर क्या करते हैं and? क्योंकि हम किसी सूची के हिस्सों को पुनरावृत्ति कर रहे हैं, हमें l2 या अधिक तत्वों और अन्यथा एक खाली सूची के सत्य होने के लिए बाईं ओर की आवश्यकता है । l[1:]इस कसौटी को अच्छी तरह से संतुष्ट करता है।

— Sisyphus
स्रोत

1

सी # (मोनो) , 81 बाइट्स

using System.Linq;a=>a.Select((_,i)=>a.Take(++i).OrderBy(n=>n).Skip(i-2).First())

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

— TheLethalCoder
स्रोत

1

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

a₀ᶠb{okt}ᵐ

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

— आउटग्रॉफर को एरिक करें
स्रोत

1

बैच, 123 बाइट्स

@set/af=s=%1
@for %%n in (%*)do @call:c %%n
@exit/b
:c
@if %1 gtr %s% set s=%1
@if %1 gtr %f% set/as=f,f=%1
@echo %s%

— नील
स्रोत

1

APL (Dyalog) , 15 बाइट्स

(2⊃⍒⊃¨⊂)¨1↓,\∘⊢

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

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

1

05AB1E , 5 बाइट्स

5-बाईटर मिला, एरिक के समाधान से बहुत अलग है । मनमाना मूल्य सूची का पहला तत्व है।

ηε{Áθ

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

व्याख्या

ηε{Áθ  - Full program that reads implicitly from STDIN and outputs to STDOUT.

η      - Push the Prefixes of the list.
 ε     - Apply to each element (each prefix):
  {      - Sort the prefix list.
   Á     - Shift the list to the right by 1, such that the first element goes to the 
           beginning  and the second largest one becomes the last.
    θ    - Get the last element (i.e. the second largest)
         - Print implicitly.

आइए एक उदाहरण लेते हैं, जिससे समझने में आसानी हो।

पहले हमें निहित इनपुट मिलता है, आइए हम बताते हैं [1, 5, 2, 3, 5, 9, 5, 8]।
फिर, हम इसके उपसर्गों का उपयोग करके धक्का देते हैं η- [[1], [1, 5], [1, 5, 2], [1, 5, 2, 3], [1, 5, 2, 3, 5], [1, 5, 2, 3, 5, 9], [1, 5, 2, 3, 5, 9, 5], [1, 5, 2, 3, 5, 9, 5, 8]]।
अब, कोड सूची के माध्यम से मैप करता है और प्रत्येक उपसर्ग का उपयोग करके सॉर्ट करता है {- [[1], [1, 5], [1, 2, 5], [1, 2, 3, 5], [1, 2, 3, 5, 5], [1, 2, 3, 5, 5, 9], [1, 2, 3, 5, 5, 5, 9], [1, 2, 3, 5, 5, 5, 8, 9]]।
हम फिर बहुत अंतिम तत्व लेते हैं और इसे शुरुआत में ले जाते हैं [[1], [5, 1], [5, 1, 2], [5, 1, 2, 3], [5, 1, 2, 3, 5], [9, 1, 2, 3, 5, 5], [9, 1, 2, 3, 5, 5, 5], [9, 1, 2, 3, 5, 5, 5, 8]]:।
बेशक, अब कोड का उपयोग करके प्रत्येक सबलिस्ट का अंतिम तत्व प्राप्त होता है θ- [1, 1, 2, 3, 5, 5, 5, 8](पहले वाला मनमाना मूल्य।

— मिस्टर एक्सकोडर
स्रोत

1

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

{_,,:)\f{<$-2=}}

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

पहले के लिए पहला तत्व देता है।

-2 चैलेंजर 5 को धन्यवाद ।

— आउटग्रॉफर को एरिक करें
स्रोत

{_,,:)\f{<$-2=}} दो बाइट्स कम है।

— फल

1

आर , 54 49 बाइट्स

Giuseppe -5 बाइट्स के लिए धन्यवाद । मैं इस सुविधा को नहीं जानता था seq()।

for(i in seq(x<-scan()))cat(sort(x[1:i],T)[2],"")

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

— djhurio
स्रोत

1

seq(x<-scan()) कुछ बाइट्स से छोटा है।

— Giuseppe

1

जाप , 12 10 बाइट्स

आउटपुट सरणी में वांछित अनुक्रम के बाद इनपुट सरणी में पहला तत्व होता है।

£¯YÄ n< g1

झसे आज़माओ

व्याख्या

सरणी का निहित इनपुट U।

£

मैप इंडेक्स U, जहां Yवर्तमान सूचकांक है।

¯YÄ

स्लाइस Uसे 0करने के लिए Y+1।

n<

अवरोही क्रम।

g1

दूसरा तत्व प्राप्त करें।

परिणामस्वरूप सरणी का उत्पादन।

— झबरा
स्रोत

1

MATL , 19 10 बाइट्स

लुइस मेंडू को 9 बाइट्स से शेविंग करने के लिए धन्यवाद!

"GX@:)SP2)

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

व्याख्या

"GX@:)SP2)
"                  for all the values in the input
 G                 get input
  X@:)             get values up to the iteration
      SP           sort it in descending order
        2)         get the second value
                   implicit end of loop and output

— डैनमैन
स्रोत

@LuisMendo वाह! यह दिखाने के लिए जाता है कि मैं MATL के बारे में कितना जानता हूं। सहायता के लिए धन्यवाद!

— DanTheMan

1

जे, 13 बाइट्स

_2&{@/:~ ::#\

इसे ऑनलाइन आज़माएं! पहला तत्व हमेशा 1 होता है।

व्याख्या

_2&{@/:~ ::#\
            \  Apply to prefixes
_2&{@/:~        Sort and take second-to-last atom
     /:~         Sort upwards
_2 {             Take second-to-last atom
         ::     If there's an error (i.e only one atom)
           #     Return the length of the list (1)

स्पेस मायने रखता है।

— गोभी
स्रोत

1

ओम , 10 8 बाइट्स

-2 बाइट्स ETHproductions के लिए धन्यवाद।

∙p»îS2~ª

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

उह, यह अजीब है, लेकिन मुझे नहीं पता कि एक नकारात्मक संख्या को कैसे आगे बढ़ाया जाए ... मुझे वास्तव में ओम नहीं पता है। : पी

— पूरी तरह से
स्रोत

1

ठीक है, 0 2-बहुत अजीब लगता है ...

— श्री Xcoder

1

डॉक्स को देखकर (मुझे ओम के बारे में कुछ नहीं पता है), क्या आप कर सकते हैं 2~?

— ETHproductions

@TEHProductions ओह, बहुत बेहतर। धन्यवाद!

— पूरी तरह से अमानवीय

0

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

Sort[s[[;;i]]][[-2]]~Table~{i,2,Length[s=#]}&

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

— J42161217
स्रोत

0

पर्ल 5 , 42 + 1 (-ए) = 43 बाइट्स

say((sort{$b<=>$a}@F[0..$_])[1])for 1..$#F

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

— Xcali
स्रोत

0

स्विफ्ट 3 , 67 बाइट्स

func g(l:[Int]){print((1..<l.count).map{l[0...$0].sorted()[$0-1]})}

परीक्षण सूट।

स्विफ्ट 3 , 65 बाइट्स

{l in(1..<l.count).map{l[0...$0].sorted()[$0-1]}}as([Int])->[Int]

परीक्षण सूट।

इन्हें कैसे चलाया जाए?

पहला एक पूर्ण फ़ंक्शन है जो इनपुट को फ़ंक्शन पैरामीटर के रूप में लेता है और परिणाम को प्रिंट करता है। आप उन्हें परीक्षण लिंक में दिखाए अनुसार उपयोग कर सकते हैं। मैंने हालांकि निर्देश जोड़ने का फैसला किया, क्योंकि दूसरे प्रकार के फ़ंक्शन का उपयोग बहुत कम ही किया जाता है और अधिकांश लोगों को इसके अस्तित्व का पता भी नहीं होता है। उपयोग:

g(l: [1, 1, 2, 2, 3, 3, 4] )

दूसरा एक अनाम फ़ंक्शन है, जैसे लैम्ब्डा। आप इसे वैसा ही उपयोग कर सकते हैं जैसा कि आप इसे पायथन करेंगे, एक चर घोषित करते हुए fऔर इसे कॉल करते हुए:

var f = {l in(1..<l.count).map{l[0...$0].sorted()[$0-1]}}as([Int])->[Int]

print(f([1, 1, 2, 2, 3, 3, 4]))

या इसे कोष्ठक के बीच लपेटें और इसे सीधे कॉल करें ( (...)(ArrayGoesHere)):

print(({l in(1..<l.count).map{l[0...$0].sorted()[$0-1]}}as([Int])->[Int])([1, 1, 2, 2, 3, 3, 4]))

— मिस्टर एक्सकोडर
स्रोत

0

PHP, 53 बाइट्स

for(;a&$n=$argv[++$i];rsort($a),print$a[1]._)$a[]=$n;

कमांड लाइन तर्कों से इनपुट लेता है। आउटपुट सीमांकित, सीसा और अनुगामी द्वारा अर्धवृत्त। इसे ऑनलाइन
चलाएं -nrया इसके लिए प्रयास करें ।

PHP 7.1 में चेतावनी देता है; ठीक करने के a&साथ बदलें ""<।
या उपयोग for(;++$i<$argc;rsort($a),print$a[1]._)$a[]=$argv[$i];(54 बाइट्स)

— टाइटस
स्रोत

0

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

स्वतंत्र रूप से @Jenny_mathy के समान उत्तर पर पहुंचे, लेकिन 3 बाइट्स छोटे

Sort[#[[;;i]]][[-2]]~Table~{i,2,Length@#}&

एहसास हुआ कि 1 रनिंग अधिकतम केवल 15 बाइट्स और दो फ़ंक्शन कॉल लेता है !:

Max~FoldList~#&

यह इतनी बारीकी से किया जा सकता है क्योंकि Maxइसमें विशेषताएँ हैं Flatऔर OneIdentityलेकिन यह सच नहीं है RankedMaxजिसके लिए तार्किक प्रतिस्थापन होगा। दुर्भाग्य से विशेषताओं को परिभाषित करना या उन्हें मौजूदा कार्यों पर संशोधित करना बहुत अधिक बाइट्स का रास्ता बनाता है, इसलिए चपटे को अन्य तरीकों से किया जाना चाहिए।

Nth चलाने वाले सभी अधिकतम 48 बाइट्स में पाए जा सकते हैं:

PadLeft[Sort/@Flatten/@FoldList[{##}&,{},#&@#]]&

— केली लोवेर
स्रोत

0

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

FNr2hlQ@_S<QN1

इसे यहाँ आज़माएँ: https://pyth.herokuapp.com/?code=FNr2hlQ%40_S%3CQN1&input=%5B1%2C+5%2C+2%2C+3%2C+3%2C+5%2+9%2C+5% 2C + 8% 5D और डिबग = 0

व्याख्या

FNr2hlQ - काउंटर 2 <= N <= सूची लंबाई के साथ लूप के लिए

@_S<QN1 - दूसरा तत्व जब सूची के पहले एन तत्वों को आरोही क्रम में सॉर्ट किया जाता है और फिर उलट दिया जाता है (अवरोही क्रम में सॉर्ट किया जाता है)

— करण इलांगोवन
स्रोत

0

k , 13 बाइट्स

{x(>x)1}'1_,\

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

           ,\ /sublists of increasing lengths (scan concat)
         1_   /remove the first sublist
{      }'     /for each sublist:
  (>x)        /    indices to permute sublist into largest to smallest
      1       /    get second index
 x            /    get sublist[that index]

— zgrep
स्रोत

0

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

@(a){[~,I]=cummax(a);a(I(2:end))=-inf;cummax(a)}{3}

- पहले तत्व के लिए एक मनमाना मान लौटा।

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

— rahnema1
स्रोत

0

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

संपादित करें: जोड़ा गया 8 बाइट्स संख्यात्मक छँटाई वांछित है। :(

a=>a.map((_,b)=>a.slice(0,b+1).sort((a,b)=>b-a)[1])

हालांकि, इसे छोटा रखते हुए, यह सुनिश्चित करने के लिए कि कोई लेक्सोग्राफिक ऑर्डर चाहता है:

a=>a.map((_,b)=>a.slice(0,b+1).sort()[b-1])

दोनों भाव उत्पन्न करते हैं undefined पहले तत्व के लिए ।

टेस्ट कोड

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

const golfed =

a=>a.map((_,b)=>a.slice(0,b+1).sort((a,b)=>b-a)[1])

const inputs = [
  [1, 5, 2, 3, 5, 9, 5, 8],
  [1, 1, 2, 2, 3, 3, 4],
  [2, 1, 0, -1, 0, 1, 2]
];
console.log(inputs.map(x => golfed(x)));
// [ [ undefined, 1, 2, 3, 5, 5, 5, 8 ],
//   [ undefined, 1, 1, 2, 2, 3, 3 ],
//   [ undefined, 1, 1, 1, 1, 1, 2 ] ]

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

— हारून पहाड़ी
स्रोत

ध्यान दें कि मैंने मौजूदा जेएस पोस्ट पर केवल टिप्पणी करना पसंद किया होगा यदि यह प्रतिष्ठा प्रणाली के लिए नहीं था।

— एरोन हिल

PPCG में आपका स्वागत है! मुझे 50-प्रतिनिधि टिप्पणी की सीमा पसंद नहीं है, लेकिन मुझे लगता है कि उन्हें टिप्पणी करने से स्पैमर्स रखने की आवश्यकता है। वैसे भी, मुझे लगता है कि यह असफल हो इनपुट एक दोहरे अंक संख्या में शामिल होगा जैसे 10, के रूप में .sort()कोषगत डिफ़ॉल्ट रूप से प्रकार (यानी 1,10,100,11,12,13, ..., 2,20,21, ...)। आपको (a,b)=>a-bइसे संख्या द्वारा क्रमबद्ध करने के लिए शामिल करने या समान करने की आवश्यकता होगी ।

— ETHproductions

धन्यवाद, @ETHproductions मैंने संख्यात्मक क्रम के लिए अद्यतन किया है, जिसका अर्थ है कि यह अब बहुत अच्छा नहीं है। ओह अच्छा।

— आरोन हिल

0

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

#(for[i(drop 2(reductions conj[]%))](nth(sort-by - i)1))

शायद उन उपसर्गों को उत्पन्न करने का एक बेहतर तरीका है।

— निकोनिरह
स्रोत

एक सूची के दूसरे अधिकतम चल रहा है

उदाहरण

05AB1E , 5 बाइट्स

भूसी , ९ by बाइट्स

explaination

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

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

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

पायथ , 8 बाइट्स

कैसे?

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

व्याख्या

जावा (ओपनजेडके 8) , 87 86 बाइट्स

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

सी # (मोनो) , 81 बाइट्स

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

बैच, 123 बाइट्स

APL (Dyalog) , 15 बाइट्स

05AB1E , 5 बाइट्स

व्याख्या

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

आर , 54 49 बाइट्स

जाप , 12 10 बाइट्स

व्याख्या

MATL , 19 10 बाइट्स

व्याख्या

जे, 13 बाइट्स

व्याख्या

ओम , 10 8 बाइट्स

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

पर्ल 5 , 42 + 1 (-ए) = 43 बाइट्स

स्विफ्ट 3 , 67 बाइट्स

स्विफ्ट 3 , 65 बाइट्स

इन्हें कैसे चलाया जाए?

PHP, 53 बाइट्स

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

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

व्याख्या

k , 13 बाइट्स

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

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

टेस्ट कोड

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