34

इसलिए, मैंने खुद को वन-लाइनर लिखा, जिसने सांप को सांप पर से निकाला। यह थोड़ा मजेदार है, और मुझे आश्चर्य है कि मैं अपने कोड को कैसे संघनित कर सकता हूं ...

यहाँ (लघु) उदाहरण आउटपुट है:

यहाँ चश्मा है:

प्रत्येक पंक्ति में, एक एकल गैर-व्हाट्सएप चरित्र (जो भी आपको पसंद है) कंसोल पर मुद्रित होता है, शुरू में इसके बाईं ओर 29 से 31 रिक्त स्थान पैडिंग के साथ।
प्रत्येक पुनरावृत्ति, एक यादृच्छिक निर्णय इन तीन कार्यों के बीच किया जाता है
- पैडिंग की मात्रा 1 से घट जाती है
- पैडिंग की मात्रा समान रहती है
- पैडिंग की मात्रा 1 से बढ़ जाती है

ऐसा 30 बार करें, 30-खंड लंबे सांप को सांत्वना में मुद्रित करने के लिए।

बाइट्स जीत में सबसे छोटा जवाब।

code-golf ascii-art random

— AJFaraday
स्रोत

क्या हम लाइनों की एक सरणी लौटा सकते हैं? क्या प्रमुख / अनुगामी स्थान या नई सीमाएँ अनुमत हैं?

— झबरा

1

मुझे लगता है कि प्रत्येक पंक्ति पर रिक्त स्थान की अनुमति है, है ना?

— लुइस मेंडो

1

"यादृच्छिक" का क्या अर्थ है? समान रूप से यादृच्छिक? तीन परिणामों में से प्रत्येक पर सकारात्मक समर्थन के साथ किसी भी वितरण से यादृच्छिक? किसी भी वितरण से यादृच्छिक? क्या कार्यक्रम के प्रत्येक रन पर परिणाम अलग-अलग होने चाहिए?

— नथानिएल

1

ध्यान दें, डिफ़ॉल्ट रूप से, यादृच्छिक का मतलब समान रूप से नहीं है । उदाहरण के लिए, मेरे दिमाग़ के उत्तर का दूसरा हिस्सा (अभी के रूप में) पूरी तरह से वैध है, इसके बावजूद यह ज्यादातर समय एक सीधी रेखा पैदा करता है।

— जो राजा

1

अभी, दो बिंदु हैं जो स्पष्ट नहीं हैं: 1) क्या यादृच्छिक का मतलब समान रूप से यादृच्छिक है? ( इस उत्तर को प्रभावित करता है ) और 2) क्या हर बार आउटपुट अलग होना चाहिए? (यानी, रैंडम नंबर जनरेटर को अनसाइड किया जा सकता है? इस उत्तर को प्रभावित करता है )

— DJMcMayhem

14

05AB1E , 15 14 बाइट्स

30DF2Ý<+ΩD0sú,

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

उपयोग करता है 0।

व्याख्या

30DF2Ý<+ΩD0sú,
30D            # Push 30 to the stack (One for the amount of iterations we are going to perform and one for the initial padding)
   F           # Pop one of the 30s and perform the following that many times...
    2Ý          # Push [0,1,2] ...
      <         # and create [-1,0,1] from that
       +        # Add the last padding to every entry (e.g. 30 in the beginning resulting in [29,30,31]
        Ω       # Pick one of the results at random ...
         D      # and push it to the stack twice
          0     # Push 0 (Any character will work fine here) ...
           sú   # and pad it with the randomly chosen amount of spaces in the front
             ,  # Finally print the result with a trailing newline

— Datboi
स्रोत

38

05AB1E: 0-बाइट्स, इसे ऑनलाइन आज़माएं! ... रुको, नहीं, लगभग यद्यपि।

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

14

रैंडम ब्रेनफक , 123 122 121 बाइट्स

+[--[<]>>+<-]>+[->+>+>+<<<]++++++++++>>++<[>>[->+<<.>]>[-<+>]>?>+++<[>->+<[>]>[<+>-]<<[<]>-]>-->,<[-<<<+>>>]<<<<+.-<<.>-]

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

रैंडम ब्रेनफक ?कमांड के सहायक जोड़ के साथ ब्रेनफक का विस्तार है , जो वर्तमान सेल को रैंडम बाइट सेट करता है। यह !एस के बने सांप को प्रिंट करता है , जो फन वाले सांपों की तुलना में अधिक मजेदार लगता है।

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

+[--[<]>>+<-]>+ Create the value 30
[->+>+>+<<<]    Copy it three times
++++++++++      Create a newline cell
>>++<            Adds 2 to the second copy to make it a space and move to the counter
[ While counter
  >>[->+<<.>]>[-<+>] Print out the padding cell number of spaces
  ?>+++<[>->+<[>]>[<+>-]<<[<]>-] Get 3-(random byte%3)
  >-->,<[-<<<+>>>]   Add (result-2) to the padding cell
  <<<<+.-<           Print an exclamation mark
  <<.                Print a newline
  >-                 Decrement counter
] end loop

एक और उपाय जो चिपक जाता है आत्मा के बजाय प्रश्न पत्र से ।

87 बाइट्स

+[--[<]>>+<-]>+[->+>+>+<<<]++++++++++>++>[>[->+<<<.>>]>[-<+>]?[,<+>]?[,<->]<<<+.-<.>>-]

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

यह एक अकेले गद्दी छोड़ने के प्रति भारी पक्षपाती है, लेकिन गद्दी को बढ़ाना या घटाना दोनों समान रूप से संभव है। हर एक को होने के लिए 256 मौका में 1 से थोड़ा कम है।

— मजाक कर रहा है
स्रोत

बहुत अच्छा! मैं ?आज्ञा से अनजान था । +1

— ग्रांट मिलर

@GrantMiller रैंडम ब्रेनफक? में ही उपलब्ध है , क्लासिक ब्रेनफक में नहीं

— जो किंग

8

सी (जीसीसी) , 61 58 56 बाइट्स

नियम परिवर्तनों को प्रतिबिंबित करने के लिए संपादित उत्तर ...

i;f(s){for(s=i=31;--i;printf("%*d\n",s+=1-rand()%3,8));}

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

— cleblanc
स्रोत

s+=1-rand()%3प्रिंटफ फ़ंक्शन पर जाकर एक बाइट को सहेजें । i;f(s){for(s=i=31;--i;)printf("%*c\n",s+=1-rand()%3,43);}

— वालुस

@Vaelus जो पहली पंक्ति बनाता है उसके पास प्रश्न में निर्दिष्ट 30 के बजाय रिक्त स्थान की एक अलग राशि है।

— स्टेडीबॉक्स

@Steadybox जो स्पष्ट रूप से टिप्पणियों में अनुमति दी गई है ..

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

7

रेटिना , 24 बाइट्स


30* +
-29{¶<`^
 
S,2@1`

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

व्याख्या


30* +

पहली पंक्ति में काम करने वाले स्ट्रिंग को शुरू करें, यानी 30 रिक्त स्थान और ए +।

-29{¶<`^

दूसरी लाइन पर एक जगह है। -29{कार्यक्रम के शेष को एक लूप में लपेटता है, जो 29 बार चलाया जाता है। ¶<अनुगामी लाइनफीड के साथ प्रत्येक लूप पुनरावृत्ति की शुरुआत में काम कर रहे तार को प्रिंट करता है। परमाणु चरण स्वयं स्ट्रिंग की शुरुआत में एक स्थान सम्मिलित करता है (मूल विचार एक स्थान सम्मिलित करने के लिए है, और फिर बेतरतीब ढंग से 0-2 रिक्त स्थान हटा दें, क्योंकि यह एक बाइट है जो यादृच्छिक रूप से हटाने, डालने और नो-ऑप के बीच चुनने से छोटा है)।

S,2@1`

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

30 वीं पंक्ति, जो अंतिम लूप पुनरावृत्ति का परिणाम है, कार्यक्रम के अंत में स्पष्ट रूप से मुद्रित होती है।

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

आप जानते हैं कि 0--2 रिक्त स्थान निकालने से भी छोटा क्या है? चारों ओर रिक्त स्थान! । वैसे, नया रेटिना महान है: डी

— लियो

7

VBA, 60 59 49 बाइट्स

For l=1To 30:?Spc(30+i)"+":i=i+Sgn(Rnd()-.5):Next

इसे तत्काल विंडो में डालें और एंटर दबाएं। (सुनिश्चित करें कि स्पष्ट घोषणा बंद कर दी गई है!)

एक पंक्ति में रहने की तुलना में दूर जाने की अधिक संभावना है (अर्थात क्रियाएं समान रूप से भारित नहीं होती हैं) लेकिन यह निर्दिष्ट आवश्यकता नहीं थी (सौभाग्य से!)

{} संपादित करें के बीच की जगह को हटाने के द्वारा 1 बाइट सहेजा =1औरTo

{EDIT2} रेमोएल की टिप्पणी के लिए धन्यवाद, 10 बाइट्स सहेजे गए

पुराने संस्करणों:

'V1
i=30:For l=1 To 30:?String(i," ")&"+":i=i+Sgn(Rnd()-.5):Next
'V2
i=30:For l=1To 30:?String(i," ")&"+":i=i+Sgn(Rnd()-.5):Next

— Chronocidal
स्रोत

5

PPCG में आपका स्वागत है!

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

2

आप की जगह में कुछ बाइट्स बचा सकते हैं String(i," ")करने के लिए Spc(30+i)तो निकालें i=30:। या -1 बाइट निकालकर &। :)

— रेमोएल

7

C # (.NET Core), 112 110 106 100 99 98 बाइट्स

v=>{var r="";for(int t=30,i=t;i-->0;r+="+\n".PadLeft(t+=new System.Random().Next(3)-1));return r;}

-1 बाइट थैंक्यू @raznagul ।
-1 बाइट @ @ बहमन को धन्यवाद ।

स्पष्टीकरण:

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

v=>{                      // Method with empty unused parameter and no return-type
  var r="";               //  Result-string, starting empty
  for(int t=30,           //  Temp-integer, starting at 30
      i=t;i-->0;          //  Loop 30 times
    r+=                   //   Append the result-String with:
       "+\n"              //    The character and a new-line,
            .PadLeft(     //    left-padded with `t` spaces,
                     t+=new System.Random().Next(3)-1));
                          //    after `t` first has been changed with -1, 0, or 1 randomly
  return r;}              //  Return the result-string

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

एक अजीब बात है: अगर मैं new Random().Next()स्थानीय रूप से कई बार कॉल करता हूं (.net फ्रेमवर्क संस्करण 4.6.1) मुझे हमेशा एक ही परिणाम मिलता है। मुझे Thread.Sleep(10)कॉल के बीच मज़बूती से अलग-अलग परिणाम प्राप्त करने की आवश्यकता है । 10ms से कम की नींद के समय के साथ मुझे कभी-कभी एक ही परिणाम मिलता है। तो .net-Framework और TIO (.net-Core) में अलग-अलग PRNG हैं या कम से कम विभिन्न बीजों का उपयोग करें। यदि मैं TIO में आपके प्रोग्राम को C # में स्विच करता हूं-तो मुझे वही व्यवहार मिलता है जो मुझे स्थानीय रूप से .net-Framework में मिलता है।

— raznagul

@raznagul हम्म, C # (मोनो सी # कंपाइलर) के साथ वह आउटपुट वास्तव में अजीब है ..

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

3

@raznagul new Random()समय का उपयोग बीज के रूप में करता है इसलिए एक तंग लूप में समय समान है और इसलिए परिणाम समान है।

— TheLethalCoder

@ लॉथलॉकर: हां, मैं यही (कम या ज्यादा) उम्मीद करता हूं। अजीब बातें यह हैं कि 1) .net-Core (कम से कम TIO पर) अलग तरह से व्यवहार करता है। 2) जो मुझे Thread.Sleep(10)अलग-अलग परिणाम प्राप्त करने की आवश्यकता है और Thread.Sleep(1)यहां तक कि 9ms पर्याप्त नहीं है।

— raznagul

@raznagul अच्छी तरह से 1, 9 या 10ms के लिए सोते हुए सभी को एक ही समय के लिए सोना चाहिए, जो चल रही अन्य प्रक्रियाओं पर निर्भर करता है ... वास्तव में अजीब।

— TheLethalCoder

7

सी, 56 बाइट्स

n;f(p){n>29?n=0:f(printf("%*d\n",n++?p-rand()%3:31,0));}

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

स्पष्टीकरण:

n; // As a global variable, n is initialized to zero.
f(p)
{
    // Call the function recursively until n > 29.
    n > 29

        // At the end, set n back to zero.
        ? n=0

        // On the first iteration, n == 0 and p has an indeterminate value.
        // 'n++ ? p-rand()%3 : 31' returns 31 (without reading p), and thus
        // 30 spaces get printed. printf() returns the number of characters
        // printed, 32 (30 spaces + '0' + '\n').
        //    On subsequent iterations, p has the value the previous printf
        // call returned, which is the padding on last iteration + 2. Also,
        // n > 0, so the same expression now returns p-rand()%3, and thus
        // the padding changes either by -1, 0, or 1 spaces. The function
        // is again called with the value of the current line's padding + 2.
        : f(printf("%*d\n", n++ ? p-rand()%3 : 31, 0));
}

सी (जीसीसी) , 55 बाइट्स

n;f(p){n=n<30&&f(printf("%*d\n",n++?p-rand()%3:31,0));}

F "रिटर्न" पर निर्भर करता है जो फ़ंक्शन में n को असाइन किया गया मान है , जो अपरिभाषित व्यवहार है, लेकिन बिना किसी अनुकूलन के सक्षम होने पर जीसीसी के साथ लगातार काम करता है।

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

— Steadybox
स्रोत

6

जावास्क्रिप्ट (ईएस 8), 63 62 60 बाइट्स

एक अनुगामी न्यूलाइन शामिल है। 1 बाइट की बचत के *2-1साथ प्रतिस्थापित किया जा सकता है, -.5लेकिन प्रत्येक पंक्ति की लंबाई समान होने की संभावना है क्योंकि पिछली पंक्ति बहुत बढ़ जाएगी। बेशक, जैसा कि "यादृच्छिक" चुनौती में परिभाषित नहीं किया गया है, RNG को 55 की कुल बाइट गिनती के साथ प्रतिस्थापित किया जा सकता है ।new Date%3-1

f=(x=y=30)=>x?``.padEnd(y+=Math.random()*2-1)+`+
`+f(--x):``

इससे पहले कि मैं नाम पकड़ पाऊं किसी ने अपनी टिप्पणी को हटा दिया, इसके लिए बाइट को धन्यवाद दिया। मैं वास्तव में इस तरह से कोशिश की थी repeatऔर padStartकोशिश करने के लिए नहीं सोचा था padEnd- पता नहीं क्यों!

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

o.innerText=(
f=(x=y=30)=>x?``.padEnd(y+=Math.random()*2-1)+`+
`+f(--x):``
)()

<pre id=o>

Expand snippet

बोनस

बाइट्स की समान संख्या के लिए, यहां एक संस्करण है जो इनपुट के रूप में शुरुआती स्थान और पुनरावृत्तियों की संख्या लेता है।

f=(x,y=x)=>x?``.padEnd(y)+`+
`+f(--x,y+Math.random()*2-1):``

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

o.innerText=(
f=(x,y=x)=>x?``.padEnd(y)+`+
`+f(--x,y+Math.random()*2-1):``
)(i.value=30);oninput=_=>o.innerText=f(+i.value)

<input id=i type=number><pre id=o>

Expand snippet

— झबरा
स्रोत

f=(x=y=30)=>x?`+\n`.padStart(y+=Math.random()*2-1)+f(--x):``एक बाइट कम है (नोट: चूंकि एसओ टिप्पणियों में लाइन ब्रेक की अनुमति नहीं देता है, इसलिए मुझे वास्तव में लाइन ब्रेक का उपयोग करने के बजाय \ n टाइप करना था।)

— स्टीफनोट

धन्यवाद, @Stefnotch दुर्भाग्य से, यहां तक कि प्रारंभिक मूल्य के साथ y=31, पहली पंक्ति बहुत कम होने की संभावना होगी। tio.run/##BcFLDsIgEADQvSeZk7sQs7kzQE7hyqSYzKfRjKBCYGHp6fO/……

— झबरा

1

अगर मैं गलत हूं तो मुझे सुधारें, लेकिन क्या आपका मौजूदा समाधान भी उस मुद्दे से पीड़ित नहीं है?

— स्टेफनोट

1

चुनौती के अनुसार पहली पंक्ति में ठीक 30 स्थान होने चाहिए ।

— नाइट

1

@ नहीं, ओपी ने पुष्टि की है कि पहली पंक्ति में 29-31 स्थान हो सकते हैं लेकिन ऐसा करने के लिए बार-बार अनुरोध करने के बावजूद अभी तक उस तथ्य को चुनौती में संपादित नहीं किया गया है।

— झबरा

6

जावा 8, 89 87 बाइट्स

पहला गोल्फ, मुझे यकीन है कि यह बहुत बेहतर हो सकता है ..

संपादित करें: स्थिर पहली पंक्ति के लिए धन्यवाद Steadybox ।

l->{for(int a=31,b=a;--a>0;){System.out.printf("%"+b+"c\n",'+');b+=2-Math.random()*3;}}

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

 l->{                                           //Begin lambda
    for(int a=31,b=a;--a>0;)                  //Initialise vars, loop through 30 lines
    {
        System.out.printf("%"+b+"c\n",'+');     //Print result
        b+=2-Math.random()*3;                   //Change padding by -1, 0, or 1
    }

— JSchiff
स्रोत

5

PPCG में आपका स्वागत है! :)

— झबरा

2

३ बाइट्स

— १ead

6

पायथन 2 , 83 65 64 बाइट्स

सीधा दृष्टिकोण:

import os
k=30
exec"print' '*k+'+';k+=ord(os.urandom(1))%3-1;"*k

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

कुछ बाइट्स बचाने के लिए @Rod को धन्यवाद! @ बाइट्स के लिए शुक्रिया -1 बाइट!

संपादित करें: परिवर्तित चर नाम और आउटपुट स्ट्रिंग अक्षर 's' के लिए

88 बाइट्स के लिए अधिक साँप की तरह उत्पादन:

from random import*
s=[30,0]
exec"print' '*sum(s)+'(S)'[s[-1]+1];s+=[randint(-1,1)];"*30

— गैबर फ़ेचेते
स्रोत

1

यह मुझे पंसद है। वास्तव में साफ समाधान।

— बजे घर का बना

6

एपीएल (डायलॉग) , 20 बाइट्स

1 बाइट ने ngn के लिए धन्यवाद बचाया

↑'+'↑⍨¨-+\30,2-?29⍴3

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

— Uriel
स्रोत

¯2+--->2-

— ngn

5

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

× ³⁰Ｆ³⁰«↙+Ｍ‽³→

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

× ³⁰            Print 30 spaces (forces the desired indentation)
    Ｆ³⁰«        Repeat 30 times
        ↙+      Print a `+` and move down and left one square
          Ｍ‽³→  Move right a random number of squares from 0 to 2

केवल 10 बाइट्स होंगे यदि कोई प्रारंभिक इंडेंटेशन आवश्यकता नहीं थी।

— नील
स्रोत

@ केविनक्रूजसेन हम्म, यह अजीब है, क्योंकि चारकोल डिफ़ॉल्ट रूप से ट्रिम करना पसंद करता है।

— नील

5

PHP, 61 बाइट्स

for($p=32;$i<30;$i++)echo str_pad("+
",$p+=rand(-1,1),' ',0);

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

— chocochaos
स्रोत

8

$i<30;$i++$i++<30;2 बाइट्स बचाने के लिए किया जा सकता है।

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

2

55 बाइट्स: for($p=30;$i++<30;$p+=rand(-1,1))printf("%{$p}s\n",'+');(इसे \n1 चेर के रूप में गिना जाता है, और इसे एक वास्तविक न्यूलाइन द्वारा प्रतिस्थापित किया जाना चाहिए)

— इस्माईल मिगुएल

2

वैकल्पिक 55-बाइट लंबी, चेतावनियों के बिना:for($i=$p=30;$i--;$p+=rand(-1,1))printf("%{$p}s\n",'+');

— इस्माइल मिगुएल

5

जावा 8, 131 129 127 126 119 108 101 बाइट्स

v->{String r="";for(int i=30,j,t=i;i-->0;r+="+\n")for(j=t+=Math.random()*3-1;j-->0;r+=" ");return r;}

स्पष्टीकरण:

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

v->{                     // Method with empty unused parameter and String return-type
  String r="";           //  Result-String, starting empty
  for(int i=30,j,t=i;    //  Two index integers, and a temp integer (starting at 30)
      i-->0;             //  Loop 30 times:
      r+="+\n")          //    After every iteration: Append the character and a new-line
    for(j=t+=Math.random()*3-1;
                         //   Change `t` with -1, 0, or 1 randomly
        j-->0;r+=" ");   //    And append that many spaces to the result-String
  return r;}             //  Return the result-String

पुराना 119 बाइट उत्तर:

v->{String s="",r=s;int i=90,t=30;for(;i-->t;s+=" ");for(;i-->0;t+=Math.random()*3-1)r+=s.substring(t)+"+\n";return r;}

स्पष्टीकरण:

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

v->{                      // Method with empty unused parameter and String return-type
  String s="",            //  Temp-String, starting empty
         r=s;             //  Result-String, starting empty
  int i=90,t=30;          //  Temp integer, starting at 30
  for(;i-->t;s+=" ");     //  Fill the temp String with 60 spaces
  for(;i-->0;             //  Loop 30 times:
      t+=Math.random()*3-1//    After every iteration: Change `t` with -1, 0, or 1 randomly
    r+=s.substring(t)     //   Append the result with `60-t` amount of spaces
       +"+\n";            //   + the character and a new-line
  return r;}              //  Return the result-String

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

4

आर , 72 69 67 बाइट्स

cat(sprintf(paste0("% ",cumsum(c(30,sample(3,29,T)-2)),"s"),"+\n"))

2 अतिरिक्त बाइट्स के लिए ज़ाहिरो मोर को धन्यवाद !

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

— प्लेनैपस
स्रोत

से स्विच करने से बाइट की गिनती 2 से कम sample(3,29,T)-2हो runif(29,-1,1)जाएगी, लेकिन चालें समान रूप से अब संभव नहीं हैं। और क्या आप भी paste("%"इसके बदले स्विच कर सकते हैं paste0("% "या मैं यहां कुछ याद कर रहा हूं?

— दरार

@ लिफ्ट अगर मैं पेस्ट का उपयोग कर रहा था जिसके परिणामस्वरूप तार के % 30 sबजाय फार्म का होगा % 30s। जैसा कि आपने कहा runifकि संभावनाओं को गड़बड़ कर देगा।

— प्लैनपस

स्थानीय रूप से sprintf("%30s"), sprintf("% 30s")और sprintf("% 30 s")मेरे लिए वही परिणाम लौटाते हैं। लेकिन TIO पर केवल पहले दो के समान परिणाम हैं, इसलिए paste0("%"एक बाइट को बचाना चाहिए। और इस बात की कोई आवश्यकता नहीं है कि हर कदम की समान संभावना है।

— दरार

4

Japt , 13 बाइट्स

लाइनों की एक सरणी देता है।

30ÆQù1nH±1n3ö

झसे आज़माओ

व्याख्या

30Æ               :Create the range [0,30) and pass each through a function
   Q              :  The " character
    ù             :  Pad start to length...
           3ö     :    Random element from the range [0,3)
         1n       :    Subtract 1
       H±         :    Add the result of that to H (inititally 32)
     1n           :    Subtract 1 to avoid the possibility of the first line being 33 characters long in total

बोनस

2 बाइट्स कम के लिए , यहां एक संस्करण है जो इनपुट के रूप में शुरुआती स्थान और पुनरावृत्तियों की संख्या लेता है।

U°ÆQùU±1n3ö

कोशिश करो

वैकल्पिक आरएनजी

अंतिम 4 बाइट्स को निम्न में से किसी के साथ बदला जा सकता है:

MrJ1     :A random float between -1 and 1
Jõ ö     :Generate the range [-1,1] and return a random element
3ö É     :An alternative way of writing the method used above
½nMr     :0.5 subtracted from a random float between 0 and 1

— झबरा
स्रोत

1

वाह, विश्वास नहीं कर सकता कि हम इस समय जीत रहे हैं! मुझे लगता है कि आप इस के साथ एक बाइट को बचा सकते हैं (मोबाइल पर तो मैं वास्तव में सत्यापित नहीं कर सकता)

— ETHproductions

@ETHproductions: हा! यह वही है जो मैंने शुरू किया था। समस्या यह है, हालांकि, अगर -1पहली पुनरावृत्ति पर आरएनजी द्वारा लौटाया जाता है , तो हम कुल पंक्ति की लंबाई के साथ समाप्त हो जाएंगे 29जब यह होना चाहिए 30, 31या 32।

— झबरा

हम्म, मैं इस बारे में उलझन में हूं कि आपका संस्करण उस समय के आसपास कैसे हो जाता है ... इसके अलावा, मेरा मानना है कि ओपी ने टिप्पणियों में स्पष्ट किया है कि उन्हें परवाह नहीं है कि क्या अतिरिक्त स्थान को हटा दिया गया है या प्रारंभिक पुनरावृत्ति में जोड़ा गया है।

— 13

वास्तव में मैं "30, 31, या 32" होना चाहिए, जब-तब इसकी आवश्यकता होती है?

— ETHproductions

@ETHproductions: हम शुरू करते हैं 30और फिर जोड़ते हैं -1, 0या 1हमें देते हैं 29, 30 या 31- जोड़ते हैं "और जो हमें कुल लंबाई देता है 30, 31या 32पहली पंक्ति के लिए।

— झबरा

4

स्विफ्ट , 101 बाइट्स

import UIKit
var g=29;for _ in 0...g{print((0..<g).map{_ in" "}.joined(),0);g+=Int(arc4random()%3)-1}

व्याख्या

एक पूरा कार्यक्रम। यह एक अजीब तरह की चाल का उपयोग करता है: मॉड्यूल arc4random()का एक सदस्य है Darwin, लेकिन UIKitयह भी स्थापित फ़ंक्शन के साथ आता है, इसलिए यह एक बाइट बचाता है :) साथ ही कई बार मनमाने ढंग से तारों को दोहराने के लिए मेरे स्विफ्ट गोल्फिंग सुझावों में से एक का उपयोग करता है ।

import UIKit        // Imports the UIKit module, necessary for the RNG.
var g=29;           // Declares an integer variable g by assigning it to 30.
for _ in 0 ... g {  // Execute the code block 30 times (for each integer in [0; g]):
 print(             // Output the following:
  (0..<g).map       // For each integer in [0; g)...
   {_ in" "}        // ... return a literal space character. 
    .joined()       // ... And join the result to a single string.
             ,0     // Also print a "0" preceded by a single space (g starts from 29).
 );
g+=                 // Increment the variable g by...
   arc4random()%3   // ... A random integer, modulo 3...
   Int(...)-1       // ... Casted to an integer (yes, this is needed!) and decremented.
}

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

for _ in 0 ... g30 के बजाय अब 29 बार कोड ब्लॉक निष्पादित नहीं करता है (0 से 29 (अनन्य) से लूप)?

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

@KevinCruijssen नहीं, [00...g में सभी पूर्णांक बनाता है ; जी] । मेरा बुरा, स्पष्टीकरण तय। [00..<g में पूर्णांक उत्पन्न करेगा ; छ) : पी

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

आह, [0; g)आपने [0; g]वास्तव में मुझे भ्रमित किया है। :) हम्म, लेकिन उस मामले में शुरू करना g=30और लूप करना संभव नहीं है [1; g]?

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

@KevinCruijssen या तो खत्म हो गया लूपिंग [0; g)या [1; g]निश्चित रूप से अगर मैं चयन संभव होगा g=30बजाय, लेकिन तब print(...,0)को बदलने की आवश्यकता print(...+"0")है, क्योंकि एक अतिरिक्त (बाहरी) अंतरिक्ष 0 से पहले अन्यथा prepended किया जाएगा। किसी भी तरह से, बाइट काउंट समान रहता है।

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

4

पर्ल, 36 बाइट्स

perl -E '$#a=29;map{$#a+=rand(3)-say"@a -"}@a'

— टन हास्पेल
स्रोत

बहुत अच्छा। मैं हमेशा भूल जाता हूं कि आप एक सरणी लंबाई सेट कर सकते हैं ... और sayघटाव के लिए उपयोग करना। क्या मैं यह सोचकर सही हूं $#aकि वेतन वृद्धि के समय यह संख्या नहीं बदलती क्योंकि यह संदर्भ नहीं है?

— डोम हेस्टिंग्स

@DomHastings: यह इसलिए है क्योंकि मैं उपयोग mapकरता हूं जो पहले स्टैक पर मौजूद तत्वों को बाहर निकालता है। forनहीं होता और अप्रत्याशित लूप लंबाई होती

— टन हास्पेल

यह जानना वाकई उपयोगी है। धन्यवाद!

— डोम हेस्टिंग्स

अच्छी गोल्फिंग। मैंने एक और बाइट के साथ दाढ़ी बनाने की कोशिश की perl -E 'map{$#a+=rand(3)-say"@a -"}@a=1..30', लेकिन कभी-कभी (हर बार नहीं) सेगमेंटेशन में गलती हुई। क्या यह perl v5.22.1 और v5.16.3 में बग हो सकता है?

— Kjetil एस।

@Kjetil हाँ, यह एक अच्छी तरह से ज्ञात समस्या है जो शायद कभी तय नहीं होगी। किसी सरणी को लूप करते समय प्रविष्टियों को एक अतिरिक्त वापसी नहीं मिलती है, इसलिए यदि आप उन्हें हटाते हैं तो वे उस समय तक मुक्त हो जाते हैं जब तक कि लूप उन तक पहुंच जाता है और आप मुक्त मेमोरी को हिट करते हैं। सौभाग्य से आप वास्तविक कार्यक्रमों में ऐसा कभी नहीं करते हैं।

— टन हास्पेल

4

आर, 54 53 बाइट्स

cat(sprintf('
%*s',cumsum(c(30,sample(3,29,T)-2)),0))

उपरोक्त के समान विचार , लेकिन छोटे sprintfकोड और एक छोटे वर्ण स्ट्रिंग शाब्दिक के साथ। इसके बजाय \n(दो बाइट्स) मैं एक शाब्दिक लाइन ब्रेक (एक बाइट) का उपयोग कर रहा हूं।

Try it online!

— कोनराड रुडोल्फ
स्रोत

A field width or precision (but not both) may be indicated by an asterisk *: in this case an argument specifies the desired number.

मैं sprintfवर्षों से उपयोग कर रहा हूं और किसी भी तरह हमेशा उस हिस्से को याद किया ... अनुस्मारक के लिए धन्यवाद!

— प्लेनैपस

1

दूसरी पंक्ति कभी-कभी एक के बजाय दो रिक्त स्थान का संकेत देती है।

— स्कॉट मिलनर

@ScottMilner को इसे ठीक करने के लिए कुछ समय मिला।

— कोनराड रुडोल्फ

4

रूबी , 45 39 बाइट्स

x=30
x.times{puts' '*(x+=rand(3)-1)+?S}

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

संशोधित करना xलूप के दौरान लूप काउंटर को प्रभावित नहीं करता है। मैंने S को एक विशेष रूप से snakelike आउटपुट कैरेक्टर के रूप में चुना।

-6 बाइट्स: rand(3)-1इसके बजाय का उपयोग करें [-1,0,1].sample। धन्यवाद, एरिक डुमिनील !

— benj2240
स्रोत

x.mapइसके बजाय आप दो बाइट्स बचा सकते हैं x.times(बराबर, क्योंकि आप रिटर्न वैल्यू का उपयोग नहीं करते हैं)

— RJHunter

1

उफ़, तुम सही हो, मुझे अनदेखा करो!

— RJHunter

1

ठीक है मुझे एक बेहतर मिल गया है: rand -1..1पाँच बाइट्स से कम है[-1,0,1].sample

— RJHunter

1

@RJHunter: या rand(3)-16 बाइट कम के लिए।

— एरिक डुमिनील

1

(x=30).times{puts' '*x+?+;x+=rand(3)-1} (एक ही आकार) चुनौती के रूप में सांप के सिर के लिए बिल्कुल 30 रिक्त स्थान प्रिंट करेगा

— असोन तुहिद

4

सेंसटॉक , 237 198 बाइट्स

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

set s to "                              +"&lf
set p to s
repeat 30
set a to random(0,2)
if a equals 0
delete first char of p
else if a equals 1
put " " before p
end if
put p after s
end repeat
put s

Ungolfed / स्पष्टीकरण

set the_snake to "                              +"&lf #assign the first line of the snake
set previous_line to the_snake                        #set up for the loop

repeat 30 times                                       #loop 30x
    set action to random(0,2)                         #random add/subtract/stay the same

    if action equals 0
        delete the first character of previous_line   #SenseTalk really shines at string manipulation
    else if action equals 1
        put " " before previous_line                  #insert a character at the beginning
    end if

    put previous_line after the_snake                 #plop the new segment into the string
end repeat                                            #close the loop

put the_snake                                         #print to standard out

संपादित करें: @mustachemoses के लिए 36 बाइट्स सहेजे गए

— एलन फिशर
स्रोत

1

क्या व्हॉट्सएप जरूरी है?

— मूंछें

इसके लिए मेरा बहुत सम्मान है। विशेष रूप से 'गोल्फ भाषाओं' की पृष्ठभूमि के खिलाफ, जो कि पूरी तरह से अपठनीय प्रतीत होता है, लेकिन संक्षिप्त है। यह एक उदाहरण है कि आप अपनी भाषा के साथ क्या कर सकते हैं दिखा रहा है अच्छा है।

— AJFaraday

1

अच्छी कॉल @MustacheMoses! अपडेट किया गया।

— एलन फिशर

मैं 198 बाइट्स गिनता हूं (ठीक है, उपयोगकर्ता का नाम कई गिना जाता है)

— हाइपरएनुट्रिनो

@AllenFisher क्या आपके पास इस भाषा के लिए एक स्टैंडअलोन दुभाषिया या संकलक है जिसे मैं बैंगन डेमो प्राप्त किए बिना उपयोग कर सकता हूं?

— मूंछें

3

जे , 23 बाइट्स

echo(8":~+/)\31,1-?29$3

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

— FrownyFrog
स्रोत

3

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

1..($l=30)|%{" "*$l+"x";$l+=-1,0,1|Random}

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

से लूप्स 1के लिए $l=30। प्रत्येक पुनरावृत्ति हम $lरिक्त स्थान प्लस ए डालते हैंx पाइप लाइन पर एक स्ट्रिंग के रूप है, तो +=या तो की -1, 0, 1आधारित पर Get-Randomमें $lअगले पाश के लिए। उन तारों को पाइपलाइन से इकट्ठा किया जाता है और एक निहित Write-Outputहमें मुफ्त में एक नई-अलग सूची प्रदान करता है।

— AdmBorkBork
स्रोत

3

बाश, ५३

3 बाइट्स @ डेनिस की बदौलत बच गए

for((i=p=30;i--;p+=RANDOM%3-1));{ printf %${p}s+\\n;}

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

— डिजिटल आघात
स्रोत

p+=RANDOM%3-1काम भी करता है।

— डेनिस

@ डेनिस बेशक! धन्यवाद!

— डिजिटल ट्रॉमा

3

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

1ŒRX+
30Ç’Ð¡⁶ẋ;€0Y

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

चुना गया पात्र 0 है । यदि पात्रों की सूची की सूची को वापस करने की अनुमति दी जाती है, तो Yउसे गिरा दिया जा सकता है और जमा को 17 बाइट्स के लिए एक नाबालिक श्रृंखला में बदल दिया जा सकता है । वैकल्पिक ।

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

30' €; € 0Y | निलादिक मुख्य कड़ी।
30 | 30 से शुरू ...
  Ð¡'Ð¡ | ... सहायक लिंक को 29 बार दोहराएं और एक सूची में परिणाम एकत्र करें।
             | (इस सूची में पहले 30 शामिल हैं, इसलिए वास्तव में 30 नंबर हैं)।
      ⁶ẋ | सूची में प्रत्येक आइटम के लिए कई बार एक स्थान को दोहराएं।
        ; € 0 | प्रत्येक को एक 0 जोड़ें।
           य | और newlines से जुड़ें।
------------- +
1 .RX + | मोनाडिक हेल्पर लिंक। वैकल्पिक रूप से, आप the1ŒRX + of के बजाय use का उपयोग कर सकते हैं।
1 | शाब्दिक एक।
 ŒR | सममितीय सीमा -1 से 1 तक।
   एक्स + | उसमें एक यादृच्छिक संख्या चुनें और उसे तर्क में जोड़ें।

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

खान, एरिक और जोनाथन के समाधानों को मिलाकर, हम इसे 16 बाइट्स तक घटा सकते हैं। चुना गया पात्र 1 है ।

’r‘X
30Ç’Ð¡Ṭ€o⁶Y

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

जोनाथन एलन को हेड-अप (ऑन Ṭ€o⁶) के लिए धन्यवाद ।

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

आप मेरे 18 बेटर Ṭ€o⁶की ⁶ẋ;€0तरह इस्तेमाल कर सकते हैं और 17 से नीचे ला सकते हैं ।

— जोनाथन एलन

@JonathanAllan धन्यवाद! तीन जेली उत्तरों को मिलाकर, मैंने वास्तव में 16 बाइट्स समाप्त किए। लेकिन मैंने इसे एक माध्यमिक समाधान के रूप में पोस्ट किया क्योंकि यह पूरी तरह से मेरा नहीं है। :-)

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

3

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

printf('%*d\n',[a=31+cumsum(randi(3,1,30)-2);~a])

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

सहेजा गया 1 बाइट अब कोई लूपिंग नहीं कर रहा है। ऑक्टेव के printfरूप में अच्छी तरह से एक और बचाया fprintf।

यह नया कोड श्रेणी में 30 यादृच्छिक पूर्णांक बनाता है -1:1। यह फिर संचयी रूप से सरणी को जोड़ता है और 30 जोड़ता है, जो वांछित अनुक्रम देता है।

परिणाम fprintfएक प्रारूप के साथ प्रिंट किया जाता है जो कहता है "एक दशमलव संख्या, एक निर्दिष्ट चौड़ाई में गद्देदार, उसके बाद एक नई पंक्ति। चौड़ाई पहला मान इनपुट होगा, और दशमलव संख्या दूसरा मान इनपुट होगा। यदि संख्या। मूल्यों का इनपुट इससे अधिक है, ऑक्टेव वांछित आउटपुट प्राप्त करने के लिए प्रिंट को स्वचालित रूप से दोहराता रहेगा।

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

एक आउटपुट प्रिंट करता है जैसे:

उपरोक्त कोड हमेशा पहली पंक्ति पर ठीक 30 स्थान प्रिंट नहीं करता है। यह या तो 29, 30 या 31 होगा। इसे ठीक करने के लिए, आप इस 53 बाइट संस्करण का उपयोग करेंगे:

x=31;for i=2:x;fprintf('%*d\n',x,0);x+=randi(3)-2;end

— टॉम बढ़ई
स्रोत

आप दो बाइट्स बचा सकते हैं: x=31;for i=2:x;fprintf('%*d\n',x+=randi(3)-2,0);end

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

@ केविनक्रूजसेन मैंने इसके बारे में सोचा था, लेकिन यह उतना काम नहीं करता है। यह पहली पंक्ति में 29, 30 या 31 स्थानों के साथ शुरू होगा।

— टॉम कारपेंटर

1

@KevinCruijssen वास्तव में, कोई बात नहीं। मैंने सिर्फ ओपी टिप्पणियों पर ध्यान दिया है जो कहती है कि अनुमति है।

— टॉम बढ़ई

हां। यह थोडा कष्टप्रद है कि एक नियम टिप्पणी में है (विशेषकर चूंकि यह वर्तमान चुनौती वर्णन के साथ विरोधाभासी है)। मैंने ओपी को चुनौती को संपादित करने के लिए कहा है कि आप इसे 29, 30 या 31 से शुरू कर सकते हैं, क्योंकि वह टिप्पणियों में इसकी अनुमति देता है।

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

3

लुआ, 81 75 बाइट्स

n=30;for i=1,n do print(("%-"..n.."s+"):format(" "))n=n-2+math.random(3)end

में to_exp केवल पाश प्रवेश करने से पहले एक बार मूल्यांकन किया जाता है, एक बाइट की बचत।for i=1,n ... n

-6 धन्यवाद @ user202729

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

— lqnrd
स्रोत

1

PPCG में आपका स्वागत है! आप अपने पोस्ट में एक TIO लिंक जोड़ना चाह सकते हैं ताकि लोग आपके प्रोग्राम का अधिक आसानी से परीक्षण कर सकें।

— user202729

आप अपने जवाब को 76 बाइट तक नीचे कर सकते हैं । पृष्ठ के अलावा Lua में गोल्फ के लिए टिप्स उपयोगी हो सकते हैं।

— user202729

75 बाइट्स ।

— user202729

3

पायथन 3.6 , 84 73 69 बाइट्स

from random import*
x=30
exec("print(' '*x+'+');x+=randint(-1,1);"*x)

-11 बाइट्स के लिए @WheatWizard को धन्यवाद। -4 बाइट्स के लिए @JoKing को धन्यवाद।

— MustacheMoses
स्रोत

चूँकि आप बाइट बचाने के लिए उपयोग iकर सकते हैं, इसलिए आप इसका उपयोग नहीं करते हैं for i in[1]*30।

— गेहूं जादूगर

आप ऐसा भी कर सकते हैं from random import*कि आपको random.बाद में इसकी आवश्यकता न हो । और आप अपने बाद newline space निकाल सकते हैं :।

— गेहूं जादूगर

और अगर आप को बदलने 30के लिए साथ बदला जा सकता । 29"+".rjust(x)" "*x+"+"

— गेहूं जादूगर

वास्तव में मेरी पिछली टिप्पणी के बारे में यह 30 रिक्त स्थान होना चाहिए न कि 29। आपका वर्तमान उत्तर केवल 29 रिक्त स्थान डालता है और इस प्रकार यह युक्ति को पूरा करने में विफल रहता है। इसे 30 से 31 बदलकर तय किया जा सकता है।

— गेहूं जादूगर

1

@HeatWizard धन्यवाद! मैंने आपके परिवर्तन जोड़े हैं और आपको भी श्रेय दिया है। मैं बदल [1]*30गया [1]*xक्योंकि यह एक बाइट कम है।

— मूंछें

3

ES5, 97 95 81 बाइट्स

for(p=i=30;i--;)console.log(Array(p).join(" ",r=Math.random()*3|0,p+=r>1?-1:r)+0)

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

ES5, ~~112~~यदि कार्य प्रारूप की आवश्यकता है तो 98 बाइट्स :

function a(){for(p=i=30;i--;)console.log(Array(p).join(" ",r=Math.random()*3|0,p+=r>1?-1:r)+0)}a()

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

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

2

PPCG में आपका स्वागत है! मुझे लगता है कि आपके चर को एक समारोह के अंदर घोषित करना होगा -_=>{p=30;for(i=0;i<p;i++){console.log(Array(p).join(" ")+"+\n");r=~~(Math.random()*3);p+=r==2?-1:r}}

— ओलिवर

मैं बाइट्स मारूंगा, मैं आपको बताऊंगा। ES5 डिफ़ॉल्ट रूप से तीर फ़ंक्शन को शामिल नहीं करता है। मैं अद्यतन करता हूँ

— काइल फेयर

@ ओलिवर, फंक्शन फॉर्मेट जोड़ा गया :)

— काइल फेयरन्स

अच्छा! मुझे यकीन है कि जब यह शुरू की गई थी नहीं कर रहा हूँ, लेकिन मुझे लगता है कि आप की जगह ले सकता join(" ")साथjoin` `

— ओलिवर

@ मुझे यकीन नहीं है कि आप ES5 में ऐसा कर सकते हैं, क्या आप कर सकते हैं? मैंने सोचा था कि ES6 में एक टेम्पलेट शाब्दिक जोड़ा गया था?

— काइल फेयर

2

लाल , 54 बाइट्स

loop n: 30[loop n[prin" "]print"+"n: n - 2 + random 3]

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

— गैलेन इवानोव
स्रोत

कोड गोल्फ: आपका अपना पालतू ASCII सांप

05AB1E , 15 14 बाइट्स

व्याख्या

रैंडम ब्रेनफक , 123 122 121 बाइट्स

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

87 बाइट्स

सी (जीसीसी) , 61 58 56 बाइट्स

रेटिना , 24 बाइट्स

व्याख्या

VBA, 60 59 49 बाइट्स

C # (.NET Core), 112 110 106 100 99 98 बाइट्स

सी, 56 बाइट्स

सी (जीसीसी) , 55 बाइट्स

जावास्क्रिप्ट (ईएस 8), 63 62 60 बाइट्स

बोनस

जावा 8, 89 87 बाइट्स

पायथन 2 , 83 65 64 बाइट्स

88 बाइट्स के लिए अधिक साँप की तरह उत्पादन:

एपीएल (डायलॉग) , 20 बाइट्स

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

PHP, 61 बाइट्स

जावा 8, 131 129 127 126 119 108 101 बाइट्स

आर , 72 69 67 बाइट्स

Japt , 13 बाइट्स

व्याख्या

बोनस

वैकल्पिक आरएनजी

स्विफ्ट , 101 बाइट्स

व्याख्या

पर्ल, 36 बाइट्स

आर, 54 53 बाइट्स

रूबी , 45 39 बाइट्स

सेंसटॉक , 237 198 बाइट्स

Ungolfed / स्पष्टीकरण

जे , 23 बाइट्स

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

बाश, ५३

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

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

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

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

लुआ, 81 75 बाइट्स

पायथन 3.6 , 84 73 69 बाइट्स

ES5, 97 95 81 बाइट्स

लाल , 54 बाइट्स