मेरा जारी रखना यह सिर्फ एक बग चुनौती थी:

इनपुट:

श्वेत-रिक्त स्थान और न ही नई-लाइनों के बिना मुद्रण योग्य ASCII वर्णों से युक्त एक स्ट्रिंग।

आउटपुट:

सबसे पहले (यानी एक इनपुट के साथ इनपुट को पूर्ववत करने, और खुद को इससे पहले कि यह जोड़ने, मध्यम चरित्र को बाहर निकालकर विलोमपद में इनपुट बारी 1234567890है, यह हो जाता है 0987654321234567890)।

और फिर इस टेक्स्ट को आउटपुट करें:

0        9        8        7        6        5        4        3        2        1        2        3        4        5        6        7        8        9        0
         0       9       8       7       6       5       4       3       2       1       2       3       4       5       6       7       8       9       0
                  0      9      8      7      6      5      4      3      2      1      2      3      4      5      6      7      8      9      0
                           0     9     8     7     6     5     4     3     2     1     2     3     4     5     6     7     8     9     0
                                    0    9    8    7    6    5    4    3    2    1    2    3    4    5    6    7    8    9    0
                                             0   9   8   7   6   5   4   3   2   1   2   3   4   5   6   7   8   9   0
                                                      0  9  8  7  6  5  4  3  2  1  2  3  4  5  6  7  8  9  0
                                                               0 9 8 7 6 5 4 3 2 1 2 3 4 5 6 7 8 9 0
                                                                        0987654321234567890
                                                               0 9 8 7 6 5 4 3 2 1 2 3 4 5 6 7 8 9 0
                                                      0  9  8  7  6  5  4  3  2  1  2  3  4  5  6  7  8  9  0
                                             0   9   8   7   6   5   4   3   2   1   2   3   4   5   6   7   8   9   0
                                    0    9    8    7    6    5    4    3    2    1    2    3    4    5    6    7    8    9    0
                           0     9     8     7     6     5     4     3     2     1     2     3     4     5     6     7     8     9     0
                  0      9      8      7      6      5      4      3      2      1      2      3      4      5      6      7      8      9      0
         0       9       8       7       6       5       4       3       2       1       2       3       4       5       6       7       8       9       0
0        9        8        7        6        5        4        3        2        1        2        3        4        5        6        7        8        9        0

(दोनों दिशाओं में मध्य से बाहर की ओर, प्रत्येक वर्ण पिछली पंक्ति की तुलना में एक अधिक स्थान से अलग होता है।)

चुनौती नियम:

आपको इनपुट की लंबाई, माइनस 3 लाइनों को दो बार प्रिंट करने की आवश्यकता है। तो इनपुट के साथ 1234567890, ऊपर प्रदर्शित आउटपुट 17 लाइनें (लंबाई 10 * 2 - 3) है।
इनपुट में केवल मुद्रण योग्य ASCII (स्थान, टैब और नई-लाइन को छोड़कर) होगा।
ट्रेलिंग स्थान वैकल्पिक हैं।
एक एकल अनुगामी नई-लाइन वैकल्पिक है।
(अतिरिक्त) अग्रणी स्थान या अग्रणी नई-लाइनों की अनुमति नहीं है।
आप मान सकते हैं कि इनपुट हमेशा कम से कम चार वर्ण लंबा होगा।
मेरे विपरीत यह सिर्फ एक बग चुनौती थी, इनपुट और आउटपुट प्रारूप दोनों ही लचीले हैं। तो आपको परिणाम को स्ट्रिंग-सरणी, स्ट्रिंग-सूची, आदि के रूप में आउटपुट करने की अनुमति है।

सामान्य नियम:

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव संक्षिप्त उत्तर के साथ आने का प्रयास करें।
मानक नियम आपके उत्तर के लिए लागू होते हैं , इसलिए आपको उचित पैरामीटर और रिटर्न-टाइप, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति है। तुम्हारा फोन।
डिफ़ॉल्ट लूपोल्स निषिद्ध हैं।
यदि संभव हो, तो कृपया अपने कोड के लिए एक परीक्षण के साथ एक लिंक जोड़ें।
इसके अलावा, यदि आवश्यक हो तो एक स्पष्टीकरण जोड़ें।

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

Input: 1234567890
Output:
0        9        8        7        6        5        4        3        2        1        2        3        4        5        6        7        8        9        0
         0       9       8       7       6       5       4       3       2       1       2       3       4       5       6       7       8       9       0
                  0      9      8      7      6      5      4      3      2      1      2      3      4      5      6      7      8      9      0
                           0     9     8     7     6     5     4     3     2     1     2     3     4     5     6     7     8     9     0
                                    0    9    8    7    6    5    4    3    2    1    2    3    4    5    6    7    8    9    0
                                             0   9   8   7   6   5   4   3   2   1   2   3   4   5   6   7   8   9   0
                                                      0  9  8  7  6  5  4  3  2  1  2  3  4  5  6  7  8  9  0
                                                               0 9 8 7 6 5 4 3 2 1 2 3 4 5 6 7 8 9 0
                                                                        0987654321234567890
                                                               0 9 8 7 6 5 4 3 2 1 2 3 4 5 6 7 8 9 0
                                                      0  9  8  7  6  5  4  3  2  1  2  3  4  5  6  7  8  9  0
                                             0   9   8   7   6   5   4   3   2   1   2   3   4   5   6   7   8   9   0
                                    0    9    8    7    6    5    4    3    2    1    2    3    4    5    6    7    8    9    0
                           0     9     8     7     6     5     4     3     2     1     2     3     4     5     6     7     8     9     0
                  0      9      8      7      6      5      4      3      2      1      2      3      4      5      6      7      8      9      0
         0       9       8       7       6       5       4       3       2       1       2       3       4       5       6       7       8       9       0
0        9        8        7        6        5        4        3        2        1        2        3        4        5        6        7        8        9        0

Input: ABCD
Output:
D  C  B  A  B  C  D 
   D C B A B C D
      DCBABCD
   D C B A B C D
D  C  B  A  B  C  D

Input: =>)}]
Output:
]   }   )   >   =   >   )   }   ]
    ]  }  )  >  =  >  )  }  ]
        ] } ) > = > ) } ]
            ]})>=>)}]
        ] } ) > = > ) } ]
    ]  }  )  >  =  >  )  }  ]
]   }   )   >   =   >   )   }   ]

Input: XXxxXX
Output:
X    X    x    x    X    X    X    x    x    X    X
     X   X   x   x   X   X   X   x   x   X   X
          X  X  x  x  X  X  X  x  x  X  X
               X X x x X X X x x X X
                    XXxxXXXxxXX
               X X x x X X X x x X X
          X  X  x  x  X  X  X  x  x  X  X
     X   X   x   x   X   X   X   x   x   X   X
X    X    x    x    X    X    X    x    x    X   X

code-golf ascii-art

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

क्या प्रत्येक पंक्ति में एक समान स्थान प्रमुख हैं OK?

— Adám

@ Adám क्षमा करें, लेकिन नहीं। अनुगामी रिक्त स्थान की कोई भी संख्या ठीक है, लेकिन अग्रणी स्थान नहीं। मैं इस नियम को चुनौती में निर्दिष्ट करूँगा।

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

2

"आपको इनपुट माइनस 3 लाइनों की लंबाई प्रिंट करने की आवश्यकता है।" फिर "(लंबाई 10 * 2 - 3)"। पहला वाक्य "कोई डबल नहीं" कहता है, दूसरा "डबल" कहता है। तो कौन सा है?

— ओलिवियर ग्राएगोइरे

@ ओलिवियरग्रैओयर ओह्स, पहली पंक्ति में 2x की लंबाई शून्य से 3 होनी चाहिए। 3. फिक्स्ड

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

5

चारकोल , 14 बाइट्स

Ｅ⁻Ｌθ¹⪫θ× ι‖Ｏ←↑

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

एएसटी:

Program
├Print
│└Ｅ: Map
│ ├⁻: Difference
│ │├Ｌ: Length
│ ││└θ: Identifier θ
│ │└1: Number 1
│ └⪫: Join
│  ├θ: Identifier θ
│  └×: Product
│   ├' ': String ' '
│   └ι: Identifier ι
└‖Ｏ: Reflect overlap
 └Multidirectional
  ├←: Left
  └↑: Up

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

16 कोडपॉइंट हो सकते हैं, लेकिन UTF-8 पायथन 3 की रिपोर्ट के अनुसार यह 41 बाइट्स है। आप इसे 16 बाइट्स बनाने के लिए किस चारसेट का उपयोग करते हैं?

— Janus Troelsen

@JanusTroelsen यह एक कस्टम चारसेट है।

— निकोलस

हुं,, स्ट्रिंग्स पर काम करता है? याद रखना चाहिए कि अगली बार ...

— नील

@ नील यह समझ में नहीं आता है?

— आउटगोल्फ जूल

तकनीकी रूप से आपका संपादन गैरकानूनी है क्योंकि संबंधित प्रतिबद्ध चुनौती को स्थगित कर देता है।

— नील

7

जाप , 22 21 बाइट्स

¬Å£¬qYîÃy w ê y w ê ·

इसे ऑनलाइन टेस्ट करें!

व्याख्या

पहले 8 बाइट्स पैटर्न के नीचे-दाएं चतुर्थांश उत्पन्न करते हैं:

 ¬ Å  £    ¬ qYîÃ
Uq s1 mXY{Uq qYî} 

Uq                 : Split the input into characters.
   s1              : Slice off the first.
      mXY{      }  : Map each item X and index Y to
          Uq       :   the input split into chars,
             q     :   joined with
              Yî   :     Y spaces.

इस बिंदु पर हमारे पास उदाहरण के लिए एक सरणी है ["ABCD", "A B C D", "A B C D"]। दुर्भाग्य से, इसे वर्ग करने के लिए 13 बाइट्स लगते हैं:

y w ê y w ê ·
y w ê y w ê qR
y                : Pad each line to the same length with spaces and transpose.
  w              : Reverse the array, and
    ê            : palindromize. Now we have the bottom half of the output transposed.
      y          : Transpose back.
        w ê      : Reverse and palindromize again, giving the full output.
            qR   : Join with newlines.
                 : Implicit: output result of last expression

— ETHproductions
स्रोत

काश मैंने सोचा था कि ट्रांज़ोज़ का इस्तेमाल किया जाए - अच्छी तरह से किया गया :)

— झबरा

क्या मैं एक प्रश्न पूछ सकता हूं जिसका उत्तर जानने में मुझे डर लग रहा है? क्या आप और बाकी लोग वास्तव में इसके लघु संस्करण में कोडिंग कर रहे हैं?

— gdbj

अगर आप में हिम्मत। शायद ऩही।

— कैलक्यूलेटरफ्लेन

1

@gdbj मैं आमतौर पर ... क्या यह एक बुरा संकेत है? : पी

— ETHproductions

@ETHproductions केवल एक दोस्त को बता रहा था कि यह असली गोल्फ के समान है: सीखने के लिए निराश होना, अजीब तरह से आदी होना, और इसमें कौशल का प्रदर्शन सम्मान करता है।

— gdbj

5

05AB1E , 17 बाइट्स

g<F¹RSðN×ýû})Rû.c

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

-1 कलसवरस को धन्यवाद ।

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

आप को बदल कर एक बाइट बचा सकता है .c.∊के साथû.c

— kalsowerus

@kalsowerus और मुझे पता था कि इसका इस्तेमाल करने का कोई तरीका होगा û... धन्यवाद!

— आउटगॉल्फ जूल

5

जावास्क्रिप्ट (ईएस 6) , 159 136 129 127 बाइट्स

f=(i,x=1-(l=i.length-1),y=x<0?-x:x,[,...b]=i)=>l>x?''.padEnd(l*(l+~y))+[...b.reverse(),...i].join(''.padEnd(y))+`
`+f(i,x+1):''

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

// This is a recursive function
// First, inputs and various variable initializations
// by using defaults
let func = (
  // Text input, will not be modified through recursion
  input,

  // Current line, for the first function call we start from -lines to +lines
  // It's roughly equivalent to lines*2 but this helps us computing the spacing
  // Also computing the total amount of lines
  currentLine = 1 - (totalLines = input.length - 1),

  // Getting the absolute value of the current line (like Math.floor)
  absCurrentLine = currentLine < 0 ? -currentLine : currentLine,

  // Getting the input without it's first letter, useful for the palidrome of the input
  [,...slicedInput] = input

// Base case, stopping the recursion if the current line
// is still below the total amount of lines
) => totalLines > currentLine

  // Leading spacing
  ? ''.padEnd(totalLines * (totalLines + ~absCurrentLine)) + 

  // Putting together the palindrome version and adding spaces between the chars
    [...slicedInput.reverse(), ...input].join(''.padEnd(absCurrentLine)) + `

  // Line return + recursion call
` + f(input, currentLine + 1)
  : ''

कोडगोल्फ में पहली प्रविष्टि, मैं किसी भी स्पष्ट गलतियों के लिए अग्रिम में माफी मांगता हूं।

23 बाइट बचाने के लिए जस्टिन मेरिनर का धन्यवाद! 11 बाइट बचाने और बग रिपोर्ट के लिए क्रेग आयरे का धन्यवाद।

— Saming
स्रोत

अच्छा पहला जवाब, मेरे से +1 और PPCG में आपका स्वागत है। मैं जे एस के साथ भी परिचित नहीं हूँ, लेकिन इसे शुरू करने के लिए संभव है xपर -2 के बजाय -1, और परिवर्तन x<=lकरने के लिए ++x<=lताकि आप निकाल सकते हैं x++और एक बाइट बचाने?

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

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

— जुम

1

PPCG में आपका स्वागत है, अच्छी पहली पोस्ट और स्पष्टीकरण! यहां 133 बाइट्स के लिए गोल्फिंग की जाती है । क्या बदला गया था की व्याख्या भी शामिल है।

— जस्टिन मेरिनर

दुर्भाग्य से आपका आउटपुट अपेक्षित आउटपुट से बहुत मेल नहीं खाता है: यहाँ देखें

— क्रेग आयरे

1

यह बहुत अच्छा है, मैंने आपके नए फ़ंक्शन को जोड़ा और स्पष्टीकरण को अपडेट किया

— सैमिंग

4

SOGL V0.12 , 22 18 बाइट्स

ā,⁄H{,čFH@*∑Κ}▓±╬-

यह कोशिश करो!

स्पष्टीकरण:

ā                   push an empty array - canvas
 ,⁄H{        }      input length-1 times do
     ,                push the input
      č               chop it into chars
       FH@*           get the current iteration-1 amount of spaces
           ∑          join the chopped input with the spaces
            Κ         prepend it to the array
              ▓     space to a square
               ±    reverse each string in that list
                ╬-  quad-palindromize with 1 X and 1 Y overlap and without swapping characters

— dzaima
स्रोत

क्या ╬-चार-तरफा पलिंडोमाइज कमांड है? मैं बस यहीं चाह रहा था कि जाप में कुछ ऐसा हो ...: P

— ETHproductions

@ETHproductions Fwiw, ╬है बहुत सी बातें

— dzaima

मुझे पता है, इसलिए मैंने निर्दिष्ट किया है ╬-। लेकिन धन्यवाद, मैं किसी कारण के लिए उस पृष्ठ को नहीं पा सका

— ETHproductions

@ETHproductions ओह। यह केवल दुभाषिया की SOGLOnline प्रति में मौजूद है: / कुछ बिंदु पर मुझे दोनों को एक साथ मिलाने की जरूरत है: |

— दिज़िमा

हम्म ... आप स्वत: लागू करना चाहिए Fके लिए ∑अगर यह आवश्यक है।

— निकोलग्राफ जूल

4

पायथन 3 , 149 141 95 बाइट्स

def f(s):l=len(s)-1;[print((' '*abs(i)).join(s[:0:-1]+s).center(2*l*l+1))for i in range(1-l,l)]

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

कुछ बाइट्स बचाने के लिए @KevinCruijssen और @ETHproductions को धन्यवाद

46 बाइट बचाने के लिए @ नॉटजगन को विशेष धन्यवाद!

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

1

बदलने l=len(s);के लिए l=len(s)-1;और उसके बाद से जुड़े सभी मूल्यों को बदलने l(यानी l-1-> l; -l+2-> -l+1; आदि) 8 कम बाइट्स है। इसे यहाँ आज़माएँ।

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

1

-l+2-> 2-l:)

— ETHproductions

धन्यवाद @KevinCruijssen, दुर्भाग्य से मैं अभी संपादित नहीं कर सकता, क्या आप कृपया इसमें संपादित कर सकते हैं?

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

@KevinCruijssen बहुत बहुत धन्यवाद!

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

3

नीचे करने के लिए 95 बाइट्स का उपयोग कर centerके बजाय forपाश!

— नॉटजागन

4

पीएचपी, 145 131 बाइट्स

यह गोल्फ को अतिरिक्त बाइट के लिए कुछ सोच रहा था; लेकिन यह इसके लायक था।

while($y<=2*$e=strlen($a=$argn)-1)echo($p=str_pad)("
",$e*($e-$d=abs($y++-$e))+1),chunk_split($a.substr(strrev($a),1),1,$p("",$d));

एक प्रमुख न्यूलाइन प्रिंट करता है। ऑनलाइन के साथ पाइप के रूप में चलाएं -nRया इसे आज़माएं ।

टूट - फूट

while($y<=2*$e=strlen($a=$argn)-1)  # $e=length-1, loop through rows
                                        # 1. print linebreak and left padding
    echo($p=str_pad)("\n",$e*($e-$d=abs($y++-$e))+1),
        chunk_split(
            $a.substr(strrev($a),1)     # 2. palindromize input
            ,1,$p("",$d));              # 3. insert $e..0..$e spaces between characters

वैकल्पिक समाधान , समान लंबाई:

for($d=-$e=strlen($a=$argn)-1;$d<$e;)echo($p=str_pad)("
",$e*($e-$b=abs($d++))+1),chunk_split($a.substr(strrev($a),1),1,$p("",$b));

— टाइटस
स्रोत

1

आप इसे ऑनलाइन आज़माकर

— जॉर्गे हल्सरमन

3

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

⎕IO←0कई सिस्टम पर डिफ़ॉल्ट की आवश्यकता होती है।

{⍉m(2-d)↓⍉(m←⊖⍪1↓⊢)↑∊¨(1↓⍳d←≢⍵)↑¨¨⊂⍵}

{… } अनाम फ़ंक्शन जहां तर्क argument द्वारा दर्शाया गया है

(… )↑¨¨⊂⍵ प्रत्येक के लिए ( ¨) निम्नलिखित संख्याओं में से ( ↑) है कि प्रत्येक के कई अक्षर ( ¨पूरे)⊂ ) तर्क, आवश्यक के रूप में रिक्तियों के साथ गद्दी:

≢w तर्क में वर्णों की संख्या

d← स्टोर में घ

⍳ कि कई many ndices (0… d) - 1)

1↓ एक बूंद (शून्य)

∊¨ ε nlist (समतल) प्रत्येक

↑ रैंक बढ़ाएँ (सूचियों की सूची को एक मैट्रिक्स में बदलें)

(m←… ) निम्नलिखित टैकट फ़ंक्शन m को लागू करें रूप में परिभाषित किया गया है:

⊖ उल्टा तर्क

⍪ के शीर्ष पर

1 एक [पंक्ति]

↓ इससे गिरा

⊢ बहस

⍉ पक्षांतरित

(… )↓ ड्रॉप:

2-d = - ( डी - 2), अर्थात डी - नीचे से 2 पंक्तियाँ

mएम लागू करें

⍉ पक्षांतरित

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

— एडम
स्रोत

3

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

s->{for(int l=s.length()-1,i=-l,x=0;++i<l;x+=i<0?l:-l)System.out.printf("%1$"+(x<1?"":x)+"s"+s.join("%1$"+(i<0?-i:i>0?i:"")+"s",(new StringBuffer(s.substring(1)).reverse()+s).split(""))+"%n","");}

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

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

%1$Ns0%1$Ns9%1$Ns8%1$Ns7%1$Ns6%1$Ns5%1$Ns4%1$Ns3%1$Ns2%1$Ns1%1$Ns2%1$Ns3%1$Ns4%1$Ns5%1$Ns6%1$Ns7%1$Ns8%1$Ns9%1$Ns0%n

— ओलिवियर ग्रेजायर
स्रोत

3

पायथन 3 , 134 124 बाइट्स

f=lambda s:'\n'.join([' '*(len(s)-1)*abs(len(s)-abs(i)-2)+(' '*abs(i)).join(s[::-1]+s[1:]) for i in range(2-len(s),len(s)-1)])

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

पीपीसीजी के लिए पहली पोस्ट थोड़ी देर के लिए दुबकने के बाद। किसी भी सुझाव / सलाह की तलाश में!

सुधार के लिए @LyricLy और @ zukasz Rogalski को धन्यवाद!

— चेस वोगेली
स्रोत

1

आपको आउटपुट को फंक्शन के अंदर प्रिंट करने की ज़रूरत नहीं है, आउटपुट रिटर्न वैल्यू में दिया जा सकता है। इसके अलावा, आपको f=बाईटाउन में गिनने की ज़रूरत नहीं है , बस एक अनाम फ़ंक्शन प्रदान करना ठीक है।

— LyricLy

1

इसके अलावा, -len(s)+2बस 2-len(s), एक कम बाइट है।

— औकाज़ रोजाल्स्की

शुक्रिया @ youukasz Rogalski और @LyricLy; आपने मुझे 10 बाइट्स से बचाया है!

— चोगे Vogeli

3

हास्केल, 177 163 बाइट्स

import Data.List
k n=[1..n]>>" "
f s=let n=length s in map(\x->(k(((n-1)*(n-(abs x)))))++(intercalate (k(abs x))$map(\z->[z])$((++)=<<reverse.tail) s))[n,n-1.. -n]

फ़ंक्शन fचुनौती फ़ंक्शन है और स्ट्रिंग्स की एक सूची देता है ( [String]), इसका उपयोग करके unlinesपरीक्षण मामलों के समान दृश्य आउटपुट प्रदान करना चाहिए (main = putStr $ unlines $ f "test string" इसे संकलित करने के लिए) ।

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

@14 मिमी के लिए -14 बाइट्स धन्यवाद

— Mephy
स्रोत

1

kके रूप में परिभाषित किया जा सकता है k n=[1..n]>>" "और pके रूप में p=(++)=<<reverse.tail(आप भी इस परिभाषा इनलाइन सकते हैं)।

— नमि

2

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

Column[Join[Reverse@(s=Row/@Table[Riffle[Reverse@Rest@b~Join~b,""<>Table[" ",i]],{i,0,Length[b=Characters@#]-1}]),Rest@s],Alignment->Center]&

— J42161217
स्रोत

यह सिर्फ एक इनपुट-बग था

इनपुट:

आउटपुट:

चुनौती नियम:

सामान्य नियम:

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

चारकोल , 14 बाइट्स

जाप , 22 21 बाइट्स

व्याख्या

05AB1E , 17 बाइट्स

जावास्क्रिप्ट (ईएस 6) , 159 136 129 127 बाइट्स

SOGL V0.12 , 22 18 बाइट्स

पायथन 3 , 149 141 95 बाइट्स

पीएचपी, 145 131 बाइट्स

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

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

पायथन 3 , 134 124 बाइट्स

हास्केल, 177 163 बाइट्स

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