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

29

इस चुनौती से बहुत अधिक प्रेरित कोड गोल्फ: आपका अपना पालतू ASCII सांप - मुझे लगा कि इसे क्षैतिज बनाने से जटिलता की एक अतिरिक्त परत जुड़ जाएगी।

एक उदाहरण क्षैतिज सांप:

            0 0               
  0        0 0 000            
00 0     00       000 0      0
    000 0            0 0   00 
       0                000

और नियम हैं:

  1. सटीक रूप से वर्णों की 5 पंक्तियों को मुद्रित किया जाता है
  2. प्रत्येक पंक्ति ठीक 30 वर्णों की होती है, जिसमें रिक्त स्थान के संयोजन और आपके द्वारा अपने साँप को खींचने के लिए चुने गए वर्ण शामिल होते हैं
  3. आपका सांप 3 लाइन पर शुरू होता है
  4. अपने साँप को खींचने के लिए उपयोग की जाने वाली अगली पंक्ति को आपकी वर्तमान रेखा से बेतरतीब ढंग से चुना जाना चाहिए, ऊपर की एक पंक्ति (यदि आप पहले से लाइन 1 पर नहीं हैं) या नीचे एक पंक्ति (यदि आप पहले से ही लाइन 5 पर नहीं हैं)।
    • इन विकल्पों को समान रूप से भारित किया जाना चाहिए। इसलिए यदि आप लाइन 1 पर हैं, तो आपके पास लाइन 1 पर रहने का 50% मौका है और लाइन 2 पर जाने का 50% मौका है। यदि आप लाइन 2 पर हैं, तो आपके पास लाइन 1 पर जाने के लिए 33% मौका है, a लाइन 2 पर रहने का 33% मौका या लाइन 3 पर जाने का 33% मौका
  5. आपके सांप को हर एक लाइन पर जाने की जरूरत नहीं है।
code-golf  ascii-art  random 
— scoots
स्रोत
5
PPCG में आपका स्वागत है! यह एक अच्छी पहली चुनौती है।
— ग्यूसेप
स्पष्टीकरण के लिए, यदि हम किनारे पर हैं, तो क्या हमें समान रूप से एक ही लाइन पर रहना है (और एक अलग रेखा पर जाना है) या क्या हमारे पास गैर-समान भार हो सकता है?
— ग्यूसेप
और किनारों से, क्या हमें समान रूप से / डाउन / समान लाइन लेनी है?
— ग्यूसेप
2
हम्म ... कम से कम 5-लाइन की सीमा लोगों को दूसरे से एक चोरी के जवाब के साथ चोरी करने से रोकती है।
— मैजिक ऑक्टोपस Urn
9
क्या भौतिक रूप से मॉनिटर को बाइट के रूप में 90 ° गणना से घुमाया जाता है? : डी
— एरिक डुमिनील

जवाबों:

11

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

सहेजे गए 7 बाइट @KevinCruijssen को धन्यवाद

5 स्ट्रिंग्स की एक सरणी देता है।

f=(y=2,a=[...'  0  '])=>a[0][29]?a:f(y+=(Math.random()*(y%4?3:2)|0)-!!y,a.map((v,i)=>v+=i-y&&' '))

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

टिप्पणी की गई

f = (                       // given:
  y = 2,                    //   y = current line (0-indexed)
  a = [...'  0  ']          //   a[] = array of 5 lines
) =>                        //
  a[0][29] ?                // if all columns have been processed:
    a                       //   stop recursion and return a[]
  :                         // else:
    f(                      //   do a recursive call with:
      y += (                //     the updated value of y, to which we add -1, 0 or 1:
        Math.random() *     //       pick a random value in [0,1)
        (y % 4 ?            //         if y is neither 0 or 4:
          3                 //             multiply it by 3
        :                   //           else:
          2                 //             multiply it by 2
        ) | 0               //       force an integer value
      ) - !!y,              //     subtract either 0 or 1
      a.map((v, i) =>       //     for each value v at position i in a[]:
        v += i - y && ' '   //       append either '0' if i = y or a space otherwise
      )                     //     end of map()
    )                       //   end of recursive call
— Arnauld
स्रोत
आप -6 बाइट्स के लिए ड्रॉप dऔर उपयोग कर सकते हैं ((y%4?3:2)|0)-(y>0)। इसे ऑनलाइन आज़माएं।
— केविन क्रूज़सेन
सुधार: -7 बाइट्स। 1में new Random(...)निश्चित रूप से डिफ़ॉल्ट रूप से निहित है .. इसे ऑनलाइन की कोशिश करो।
— केविन क्रूज़सेन
@ केविनक्रूजसेन धन्यवाद! ( !!yइसके बजाय (y>0)2 और बाइट्स बचाता है।)
— अरनौल्ड
7

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

Ｐ|   Ｆ³⁰«0≡ⅉ²Ｍ‽²↑±²Ｍ‽²↓Ｍ⊖‽³↓

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

Ｐ|

आउटपुट की 5 लाइनों को बाध्य करने के लिए कुछ पैडिंग प्रिंट करें।

Ｆ³⁰«

30 बार दोहराएं।

0

एक शून्य प्रिंट करें (और क्षैतिज रूप से आगे बढ़ें)।

≡ⅉ²Ｍ‽²↑

यदि Y- समन्वय 2 है, तो 0 या 1 से यादृच्छिक रूप से आगे बढ़ें।

±²Ｍ‽²↓

यदि यह -2 है, तो बेतरतीब ढंग से 0 या 1 से नीचे जाएँ।

Ｍ⊖‽³↓

अन्यथा बेतरतीब ढंग से -1, 0 या 1 से नीचे जाएं।

— नील
स्रोत
6

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

perl -E '$%=2;s:$:$n++%5-$%&&$":emg,$%-=!!$%+rand!($%%4)-3for($_=$/x4)x30;say'

यह बिल्कुल भी इष्टतम नहीं लगता है।

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

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

3µ’o1r‘«5¥$Xµ30СṬ€o⁶z⁶Y

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

व्याख्या

3'o1r '«5 µ $ XСṬ30⁶ € o⁶z ||Y || Niladic पूरा कार्यक्रम।
                         ||
3 || 3 से शुरू ...
 || µ30 || ... 30 बार निष्पादित करें ...
               С || ... और एक सूची में परिणाम एकत्र करते हैं।
  'o1r' «5 ¥ $ X || - | मोनाडिक "हेल्पर" फ़ंक्शन।
  'ओ 1 || - | वर्तमान पूर्णांक, घटाया हुआ या १।
     आर एक्स || - | ^ से ... तक की श्रेणी से यादृच्छिक आइटम को पकड़ो
      ’« ५ || - | ... संख्या में वृद्धि, 5 से छाया हुआ (अधिकतम का उपयोग करता है)।
         | $ || - | सिंटैक्स तत्व। लिंकिंग समूह के लिए उपयोग किया जाता है।
                 Ṭ € || प्रत्येक असत्य।
                   o⁶ || तार्किक या एकल स्थान के साथ।
                     z || भराव स्थानों के साथ स्थानांतरण।
                       य || Newlines से जुड़ें।
— श्री Xcoder
स्रोत
5

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

@Ruts, @Turksarama, और @mypetlion बाइट्स को कम करने में बहुत मददगार रहे हैं

import random
m=[list(' '*30)for y in range(5)]
l=2
for i in range(1,30):
 m[l][i]=0
 l+=random.randint(~-(l<1),l<4)
for j in m:
  print(*j)

इस पर प्रयास करेंगे और सुधार करेंगे। मजेदार चुनौती!

— linemade
स्रोत
3
31 बाइट बचाने के l+=random.randint(-1,1) l=0 if l<0 else l l=4 if l>4 else lलिए बदलें l+=random.randint(~-(l<1),l<4)।
— मिथाइलियन
1
आपको बहुत सारे रिक्त स्थान और नई सूची निकालने में सक्षम होना चाहिए।
— श्री एक्सकोडर
1
7 बाइट बचाने के m=[[' 'for x in R(w)]for y in R(h)]लिए बदलें m=[list(' '*w)for y in R(h)]।
— 17
2
अजगर में, booleanएक उपवर्ग int। तो के Falseस्थान पर इस्तेमाल किया जा सकता है 0और Trueप्रतिस्थापित कर सकता है 1। ~बिटवाइज़ के लिए एक एकल ऑपरेटर है notऔर -ऑपरेटर चिह्न (गुणा flips -1)। इसलिए ~-(False)मूल्यांकन करता है -1और ~-(True)
— 0.46
1
अपने लूप के अंदर अपने शुरुआती 0 को असाइन करें और असाइनमेंट के बाद l सेट करें। यह आपको m[2][0]=0लूप ( for i in R(1,30):बन जाता है for i in R(30):) के लिए एक पूरी लाइन ( चला गया है) और 2 बाइट्स बचाता है । 0. सेट करने के बाद आपको l को पुनर्गणना करने की आवश्यकता होगी। यह आपको 144 बाइट्स तक ले जाना चाहिए।
— तुर्कसारमा
4

आर , 120 114 बाइट्स

m=matrix
r=m(" ",30,5)
x=3
for(i in 1:30){r[i,x]=0;x=x+sample(-1:1,1,,m(c(0,rep(1,13)),3)[,x])}
write(r,"",30,,"")

अतिरिक्त 6 बाइट्स के लिए @Giuseppe का धन्यवाद !

निम्नानुसार संभावनाओं की तालिका का उपयोग करता है:

> matrix(c(0,rep(1,13)),3)
     [,1] [,2] [,3] [,4] [,5]
[1,]    0    1    1    1    1
[2,]    1    1    1    1    1
[3,]    1    1    1    1    0
Warning message:
In m(c(0, rep(1, 13)), 3) :
  data length [14] is not a sub-multiple or multiple of the number of rows [3]

जहां प्रत्येक स्तंभ एक मामले से मेल खाता है, अर्थात यदि स्तंभ 1 पंक्ति में है, तो सांप 1 पंक्ति में है, क्रमशः 0, 1/2 और 1/2 चुनने के लिए - [नीचे जाएं], 0 [अभी भी रुकें] और 1 [ ऊपर जाएं] ( sampleस्वचालित रूप से संभावनाओं को 1 को सामान्य करें), पंक्ति 2 के लिए कॉलम 2 संभावनाएं 1/3, 1/3 और 1/3, आदि देता है। ...

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

— plannapus
स्रोत
— ग्यूसेप
@Giuseppe धन्यवाद! वहाँ वास्तव में यह उर्फ का कोई कारण नहीं था, और मुझे लगता है कि अतिरिक्त 0. के लिए वेक्टर रिसाइकिलिंग उपयोग करने के लिए भूल गया
— plannapus
3

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

3ā'∑∫⁵╗ž⁴H1ΧGI5χ⁴-ψ+;

यह कोशिश करो!

स्पष्टीकरण:

3                      push 3
 ā                     push an empty array - the canvas
  '∑∫                  30 times do, pushing counter            | stack = 3, [], 1
     ⁵                   duplicate the Y coordinate            | stack = 3, [], 1, 3
      ╗ž                 at those coordinates insert "+"       | stack = 3, ["","","+"]
        ⁴                duplicate from below                  | stack = 3, ["","","+"], 3
         H               decrease                              | stack = 3, [...], 2
          1Χ             maximum of that and 1                 | stack = 3, [...], 2
            G            get the item 3rd from top             | stack = [...], 2, 3
             I           increase it                           | stack = [...], 2, 4
              5χ         minimum of that and 5                 | stack = [...], 2, 4
                ⁴-       subtract from the larger a copy of the smaller value | stack = [...], 2, 2
                  ψ      random number from 0 to pop inclusive | stack = [...], 2, 2
                   +     add those                             | stack = [...], 4
                    ;    and get the array back ontop          | stack = 4, ["","","+"]

                         implicitly output the top item - the array, joined on newlines
— dzaima
स्रोत
2

स्माइलबासिक, 107 105 103 89 बाइट्स

FOR I=0TO 29FOR J=0TO 5LOCATE I,J?" 0"[Y+2==J]NEXT
Y=Y+RND(3)-1D=Y/3>>0Y=Y-D-D*RND(2)NEXT
NEXT

यह उत्तर (शाब्दिक) किनारे के मामलों के कारण लंबवत एक से अधिक दिलचस्प है।

64 बाइट्स, बिना मुद्रण स्थान:

FOR I=0TO 29LOCATE,Y+2?0;
Y=Y+RND(3)-1D=Y/3>>0Y=Y-D-D*RND(2)NEXT

मुझे एक ही लंबाई के साथ लाइन 2 की कुछ विविधताएं भी मिलीं:

Y=Y+RND(3)-1D=Y/3>>0Y=Y-D-D*RND(2)NEXT
Y=Y+RND(3)-1D%=Y/3Y=Y-D%-D%*RND(2)NEXT
Y=Y+RND(3)-1Y=Y-Y DIV 3*(RND(2)+1)NEXT
Y=Y+RND(3)-1Y=Y/3OR.Y=Y-D-D*RND(2)NEXT

Y / 3 के पूर्णांक विभाजन का उपयोग यह जांचने के लिए किया जाता है कि क्या Y वैध सीमा के बाहर है, साथ ही संकेत प्राप्त कर रहा है।

— 12Me21
स्रोत
2

जावा 8, 177 170 बाइट्स

v->{int a[][]=new int[5][30],c=0,r=2;for(;c<30;r+=Math.random()*(r%4>0?3:2)-(r>0?1:0))a[r][c++]=1;String R="";for(int[]y:a){for(int x:y)R+=x<1?" ":"~";R+="\n";}return R;}

-7 बाइट्स @ OlivierGrégoire को धन्यवाद ।

स्पष्टीकरण:

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

v->{                // Method with empty unused parameter and String return-type
  int a[][]=new int[5][30],
                    //  Integer-matrix of size 5x30
      c=0,          //  Column, starting at index 0
      r=2;          //  Row, starting at index 2
  for(;c<30;        //  Loop `c` 30 times
      r+=Math.random()*(r%4>0?3:2)-(r>0?1:0))
                    //    After every iteration: change `r` with -1,0,1 randomly
                    //     If `r` is 0: random [0;2)-0 → 0,1
                    //     If `r` is 4: random [0;2)-1 → -1,0
                    //     If `r` is 1,2,3: random [0:3)-1 → -1,0,1
    a[r][c++]=1;    //   Fill the cell at indices `r,c` from 0 to 1
  String R="";      //  Result-String, starting empty
  for(int[]y:a){    //  Loop over the rows of the matrix
    for(int x:y)    //   Inner loop over the individual column-cells of the matrix
      R+=x<1?       //    If the value of the cell is still 0:
          " "       //     Append a space
         :          //    Else (it's 1):
          "~";      //     Append the character
    R+="\n";}       //   After every row, Append a new-line
  return R;}        //  Return the result-String
— केविन क्रूज़सेन
स्रोत
1
r+=Math.random()*(r%4>0?3:2)-(r>0?1:0)कुछ बाइट्स बचाने के लिए।
— ओलिवियर ग्रेजायर 13
@ ओलिविएरग्रेयर मुझे लगा कि मैं पहले ही ऐसा कर चुका हूं, लेकिन जाहिर तौर पर ऐसा नहीं है। शायद मैंने हाल ही में एक और जवाब में यह किया है: एस धन्यवाद!
— केविन क्रूज़सेन
2

सी (जीसीसी) , 134 130 बाइट्स

r,x,y=3,a[31],m;f(){for(x=0;x<31;x++){m?putchar(x==30?10:a[x]-m?32:48):(a[x]=y);r=rand();y+=y==1?r%2:y==5?-r%2:1-r%3;}++m<6&&f();}

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

— मासी
स्रोत
PPCG में आपका स्वागत है!
— मार्टिन एंडर
धन्यवाद! प्रिंटफ़ के बजाय पुचर का उपयोग करने से 4 बाइट बचती हैं।
— MaSi
1

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

from random import*
i,*a=2,
exec("a+=i,;i+=randint(-(i>0),i<4);"*30)
for x in range(5):print(''.join(' 0'[x==i]for i in a))

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

पूर्णांक की एक सरणी उत्पन्न करें, फिर इसे प्रत्येक पंक्ति में बदलें।

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

from random import*
i=2;a=[]
exec"a+=i,;i+=randint(-(i>0),i<4);"*30
for x in range(5):print''.join(' 0'[x==i]for i in a)

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

Py2 के लिए, निरर्थक parens के लिए execऔर printहटाया जा सकता है, लेकिन दूसरी पंक्ति में वाक्यविन्यास अमान्य है।

दोनों Py2 प्रस्तुत रॉड और Py3 द्वारा प्रस्तुत द्वारा घर का बना ।

— bubbler
स्रोत
1

रूबी , 98 77 बाइट्स

->{a=(0..4).map{" "*30}
x=2
30.times{|i|a[x][i]=?@
x+=rand(3-17[x])-30[x]}
a}

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

एक लंबोतरा तार की एक सरणी लौटाता है।

मेरा प्रारंभिक आवेग स्तंभों को उत्पन्न करने और उन्हें स्थानांतरित करने के लिए था, लेकिन यह सिर्फ उस कदम से बचने के लिए बहुत आसान है।

मैं प्रारंभ करने में पसंद आया है | aसाथ [" "*30]*5, लेकिन उस तार के उथले प्रतियां बनाना होगा, एक बहुत ही वसा, गैर slithery साँप हो जाती है।

मैं Dवेतन वृद्धि (उसी बाइट काउंट के लिए) की तरह एक स्थिरांक का उपयोग कर सकता था , लेकिन रूबी ने इसे सौंपे जाने पर हर बार शिकायत की होगी। मैंने फैसला किया कि मैं iमिड-लूप को फिर से अनदेखा करने के लिए डिबग चेतावनियों का एक गुच्छा होने से पठनीयता कम करना पसंद करता हूं ।

मैं भी कुछ बाइट्स को बचाने के लिए पसंद करता था loop{x+=rand(3)-1;(0..4)===x&&break}, लेकिन इससे किनारों पर एक पूर्वाग्रह पैदा हो जाता था: 1/3 को पीछे की ओर मुड़ने का मौका, रहने के लिए 1/3 मौका, और 1/3 के लिए सीमा से बाहर जाने का मौका थोड़ी देर पहले अंत में यादृच्छिक-घूमना (यानी "रहना")।

-20 बाइट्स:Integer#[] सभी 5 पदों के लिए सही मूवमेंट वेटिंग सुनिश्चित करते हुए, रूबी की छोटी-छोटी स्थिति बनाने के लिए उपयोग करें । यह एक बड़ी बचत के लिए लूप-ब्रेक पैटर्न (एक असफलता को रोकने में नाकाम रहने के साथ) को बदल देता है। धन्यवाद, एरिक डुमिनील !

-1 बाइट: एरिक डुमिनील के लिए फिर से धन्यवाद, के बजाय के aसाथ प्रारंभ करें ।(0..4).map5.times

->{
  a = (0..4).map{ " " * 30 }      # a is the return array: 5 strings of 30 spaces
  x = 2                           # x is the snake position
  30.times{ |i|                   # For i from 0 to 29
    a[x][i] = ?@                  #   The ith position of the xth row is modified
    x += rand(3 - 17[x]) - 30[x]  #   Using bit logic, add rand(2 or 3) - (0 or 1)
  }
  a                               # Return the array of strings
}
— benj2240
स्रोत
अच्छी शुरुआत। भीतर की कोई जरूरत नहीं loop। आप के साथ वेतन वृद्धि की गणना कर सकते rand(2+14[x])-30[x]या rand -(30[x])..15[x]। शायद एक छोटा संस्करण है। फिर भी, -20 बाइट्स बुरा नहीं है! इसे ऑनलाइन आज़माएं!
— एरिक डुमिनील
1 बाइट के साथ कम x,a=2,(0..4).map{" "*30}। इसे ऑनलाइन आज़माएं!
— एरिक डुमिनील
1
वाह, 30[x]बहुत बढ़िया चाल है! धन्यवाद!
— बेंज 2240
1

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

.join.say for [Z] ((' ',' ',0,' ',' '),{.rotate(set(0,+?.[0],-?.[4]).pick)}...*)[^30]

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

लंबी पैरेंटाइज़्ड अभिव्यक्ति प्रारंभिक तत्व से उत्पन्न एक आलसी अनुक्रम है (' ', ' ', 0, ' ', ' '), जो आउटपुट की पहली ऊर्ध्वाधर पट्टी है। प्रत्येक क्रमिक पट्टी / सूची पूर्ववर्ती एक से इसकी rotateविधि को कॉल करके उत्पन्न होती है , जिसमें एक सेट से बेतरतीब ढंग से चुना जाता है 0, 1(यदि पहला तत्व नॉनजरो है), और -1(यदि पांचवां तत्व नॉनजरो है)।

क्षैतिज स्ट्रिप्स के मैट्रिक्स को [Z]ऑपरेटर के साथ स्थानांतरित किया जाता है, इसे ऊर्ध्वाधर स्ट्रिप्स की सूची में बदल दिया जाता है, जिनमें से प्रत्येक को फिर joinएक स्ट्रिंग में एड किया जाता है और इसके साथ आउटपुट होता है say।

— शॉन
स्रोत
1

स्काला, 207 बाइट्स

val b=Array.fill(150)('.')
def s(y:Int,x:Int)={val r=Random.nextInt(6)
val z=y+(if(y>3)-r%2
else if(y<1)r%2
else r/2-1)
b(z*30+x)='$'
z}
(3/:(0 to 28))(s(_,_))
b.mkString("").sliding(30,30).foreach(println)

नमूना:

...................$$$...$.$$.
.$$$..............$...$.$.$...
$...$$$..$...$$.$$.....$......
.......$$.$.$..$..............
...........$..................

degolfed:

val buf = List.fill(150)('.').toBuffer
def setRowCol (y:Int, x:Int): Int = {
  val r = Random.nextInt(6)
  val z = y + (
    if (y>3) 
        -(r%2)
    else if (y<1) 
        (r%2)
    else 
        r/2-1
  )
  buf (z * 30 + x) = '$'
  z
}
(3 /: (0 to 28)(setRowCol (_, _))
println 
buf.mkString ("").sliding(30,30).foreach(println)

मेरा अनूठा आविष्कार - ठीक है, मैंने अभी तक अन्य समाधान नहीं पढ़ा है, एक रैंडम (6) उत्पन्न करने के लिए है, जो कि दो रैंडम हैं, (2 * 3)। सीमा से दूर होने पर, मैं आर / 2 (0,1,2) के मूल्यों का उपयोग करता हूं और → (-1,0,1) मुझे बताता हूं, ऊपर या नीचे जाने के लिए। अगर सीमा पर, मैं एक और यादृच्छिक के चरित्र को महंगा कॉल से बच सकता हूं, और यह तय करने के लिए कि मैं क्या करूं या मुझे जाना चाहिए, केवल मोडुलो (2) ले लो।

आइए देखें अन्य उपाय। :)

— अज्ञात उपयोगकर्ता
स्रोत
हाँ, गलत नमूना छवि। ऐसा होता है। :)
— उपयोगकर्ता अज्ञात
स्कैला चट्टानों! ओह .. कोड गोल्फ .. गलत उपयोग मामला ऐसा प्रतीत होता है .. कैसे बिल्ली में यह द्वारा lapped हो गया java?
— जावदबा
@javadba: क्या आपने try itलिंक पर क्लिक किया है ? केविन क्रूज़सेन में कुछ बॉयलरप्लेट शामिल नहीं थे, जिन्हें इस कोड को संकलित करने या JShell में चलाने की आवश्यकता थी, लेकिन मुझे लगता है कि यह दिशानिर्देशों के अनुसार है - एक मेटा चर्चा हो सकती है। यदि आप चाहें, तो आप इस कोड को कम करने की कोशिश कर सकते हैं, दो-मंद सरणी का उपयोग करके। एक दूसरा विचार है, अंत में स्लाइडिंग कोड को कम करने के लिए। कुछ नक्शा विधि? प्रिंटल केविन द्वारा छिपाया गया है। - हाँ, ऐरे 8. द्वारा एक सुधार देता है
— उपयोगकर्ता अज्ञात
स्कैला को वापसी प्रकार int का अनुमान लगाने दें: 4 अधिक वर्ण सहेजे गए।
— उपयोगकर्ता अज्ञात
इसलिए यह अब जावा के लिए बॉलपार्क में मिल रहा है
— javadba
1

पर्ल, 83 101 बाइट्स

perl -E '$l=3;map{map$s[$_-1].=/$l/?0:" ",1..5;$l-=1-int 3*rand;$l=~y/60/51/}1..30;say for@s'

नई: सीमाओं पर संभाव्यता मुद्दे के बिना:

perl -E '$l=3;map{map$s[$_-1].=/$l/?0:" ",1..5;$l=int($l<2?1+2*rand:$l>4?6-2*rand:$l-1+3*rand)}1..30;say for@s'

Ungolfed:

$l=3;                             #start line
map{
  map $s[$_-1].=/$l/?0:" ",1..5;  #0 at current char and line, space elsewhere
  $l-=1-int 3*rand;               #up, down or stay
  $l=int( $l<2 ? 1+2*rand
        : $l>4 ? 6-2*rand
        :        $l-1+3*rand )    #border patrol
}
1..30;                            #position
say for@s                         #output result strings/lines in @s
— केजेटिल एस।
स्रोत
2
आपकी सीमा की गश्त किनारे पर रहने के लिए 50% की सही संभावना नहीं देती है।
— टन हास्पेल
0

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

$a=(,' '*30),(,' '*30),(,' '*30),(,' '*30),(,' '*30);$l=2;0..29|%{$a[$l][$_]=0;$l+=0,(1,($x=1,-1),$x,$x,-1)[$l]|Random};$a|%{-join$_}

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

5 लाइनों से 30 फीट चौड़ी 30 जगहों के 2 डी सरणी का निर्माण करता है। (एनबी - अगर कोई इस सरणी को शुरू करने के लिए बेहतर प्रभावी तरीके के साथ आ सकता है, तो मैं <3 आप हमेशा के लिए करूंगा।) सहायक चर $lको सेट करता है 2(इसका उपयोग पिछले सांप खंड पर किस लाइन के लिए किया जाता है)। तब से लूप 0करने के लिए 29।

प्रत्येक पुनरावृत्ति, हम अपने साँप तत्व को निर्धारित करते हैं 0। फिर हम एक जटिल सरणी में अनुक्रमित करते हैं, जिसके साथ Get-Randomयह पता चलता है कि क्या हम ऊपर या नीचे जाते हैं या समान रहते हैं। इसमें वापस जोड़ा गया है $l।

अंत में, हम प्रत्येक के पांच तत्वों $aऔर -joinउनके आंतरिक तत्वों को एक ही स्ट्रिंग में लूप करते हैं। उन पांच तारों को पाइपलाइन पर छोड़ दिया जाता है, और निहितार्थ Write-Outputहमें मुफ्त में नई सुर्खियां देता है।

— AdmBorkBork
स्रोत
0

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

यहाँ आते हैं:

(let[l(take 30(iterate #(max(min(+(-(rand-int 3)1)%)4)0)3))](doseq[y(range 5)](doseq[x l](print(if(= y x)0" ")))(println)))

Ungolfed संस्करण:

(let [l (take
       30
       (iterate
        #(max
          (min
           (+ (- (rand-int 3) 1) %)
           4)
          0)
        3))]
(doseq [y (range 5)]
  (doseq [x l]
    (print (if (= y x) 0 " ")))
  (println)))

सांप के शरीर की अलग-अलग ऊंचाइयों की एक सूची बनाता है, फिर 0 से 4 तक पुनरावृत्ति करता है। जब भी ऊंचाई मौजूदा पंक्ति से मेल खाती है तो यह 0, अन्यथा खाली होती है। हाइट्स को सीमा से अधिक नहीं होने देना वास्तव में बाइट्स की लागत है। यह भी पहचानना कि जब एक नई लाइन क्रम में होती है तो अधिक बाइट-सघन होती है जैसा कि होना चाहिए। एक आसानी से एक लिख सकता है doseq, एक्स और वाई के कार्टेशियन उत्पाद बना रहा है लेकिन फिर किसी को पता नहीं है कि एक नई लाइन कब प्रिंट करनी है।

— यहोशू
स्रोत
0

पायथन 3 + सुन्न, 137 132 बाइट्स

सबसे छोटा अजगर प्रस्तुत नहीं, सबसे लंबा नहीं, और निश्चित रूप से सबसे तेज़ नहीं।

from pylab import*
j=r_[2,:29]
while any(abs(diff(j))>1):j[1:]=randint(0,5,29)
for i in r_[:5]:print(''.join(' #'[c] for c in j==i))

अद्यतन का उपयोग numpyकर अलग-अलग कमांड को सहेजने के लिए 5 बाइट्स का परीक्षण किया जाता है यदि साँप एक मान्य पैटर्न है, तो मैन्युअल रूप से अंतर की गणना के मुकाबले j[1:]-j[:-1]।

— user2699
स्रोत
0

आर , 95 बाइट्स

x=3;l=1:5
write(t(replicate(30,{y=ifelse(x-l,' ',0);x<<-sample(l[abs(x-l)<2],1);y})),'',30,,'')

अगली पंक्ति xको हमेशा उन लाइनों से चुना जाता है जो वर्तमान लाइन ( l[abs(x-l)<2]) से 1 से अधिक दूर नहीं हैं । replicateएक forचक्र के बजाय का उपयोग मैट्रिक्स आरंभीकरण और हेरफेर के लिए आवश्यक कुछ बाइट्स को बचाता है और <<-वैश्विक चर को असाइन करते समय ऑपरेटर के उपयोग की आवश्यकता होती है x।

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

— रॉबर्ट हैकेन
स्रोत
0

05AB1E , 25 बाइट्स

Y30F©ð5×0®ǝs<DÌŸ4ÝÃΩ}\)ζ»

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

व्याख्या

Y                           # push the initial value 2
 30F                        # 30 times do
    ©                       # store a copy of the current value in register
     ð5×                    # push 5 spaces: "     "
        0®ǝ                 # insert 0 at the position of the current value
           s<DÌŸ            # push the range [current-1 ... current-1+2]
                4ÝÃ         # keep only numbers in [0 ... 4]
                    Ω       # pick one at random
                     }\     # end loop and discard the final value
                       )ζ   # transpose the list
                         »  # join by newlines
— Emigna
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.