이 도전에 매우 큰 영향을 받았습니다. Code Golf : 자신 만의 애완 동물 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 행에있는 경우 50 %의 확률로 1 행에 머무를 수 있고 50 %의 확률로 2 행에 옮길 수 있습니다. 33 % 확률로 2 행 유지 또는 33 % 확률로 3 행 이동
5. 뱀 이 모든 한 줄을 방문 할 필요 는 없습니다 .

JavaScript (ES6), 98 바이트

@KevinCruijssen 덕분에 7 바이트 절약

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

숯 , 28 바이트

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

Ｐ|   

5 줄의 출력을 강제하기 위해 일부 패딩을 인쇄하십시오.

Ｆ³⁰«

30 번 반복하십시오.

0

0을 인쇄하고 가로로 이동하십시오.

≡ⅉ²Ｍ‽²↑

Y 좌표가 2이면 0 또는 1 씩 무작위로 위로 이동합니다.

±²Ｍ‽²↓

-2이면 0 또는 1 씩 무작위로 내려갑니다.

Ｍ⊖‽³↓

그렇지 않으면 -1, 0 또는 1 씩 무작위로 내려갑니다.

펄, 68 바이트

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

전혀 최적의 느낌이 들지 않습니다.

젤리 , 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 ||-| Monadic "도우미"기능.
  'o1 ||-| 현재 정수로, OR이 감소합니다.
     r X ||-| ^에서 ...의 범위에서 임의의 항목을 가져옵니다.
      '«5 ||-| ... 증가한 숫자는 5로 제한됩니다 (최대 값 사용).
         ¥ $ ||-| 구문 요소. 링크를 그룹화하는 데 사용됩니다.
                 Ṭ € || 사실이 아닙니다.
                   o⁶ || 단일 공백이있는 논리 OR
                     z⁶ || 필러 공간으로 바꿉니다.
                       예 || 줄 바꿈으로 참여하십시오.

R , 138 바이트

m=matrix(" ",30,5)
m[1,3]=0
x=3
s=sample
for(i in 2:30)m[i,x<-x+(-1)^(x==5)*s(0:1,1)*x%in%c(1,5)+(s(3,1)-2)*x%in%2:4]=0
write(m,"",30,,"")

온라인으로 사용해보십시오!

plannapus에 의해 쉽게 outgolfed

파이썬 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)

이것을 시도하고 개선 할 것입니다. 재미있는 도전!

R , 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로 지정하여 각각 -1 [go down], 0 [stay still] 및 1 [ 위로 이동] ( sample확률을 자동으로 1로 정규화), 행 2의 열 2에 확률 1/3, 1/3 및 1/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

apt, 31 29 바이트

행 배열을 반환합니다.

30ÆQùU±[2V=Jõ VVJò]mö i3 gUÃy

그것을 테스트

apt , 26 바이트

30ÆQùU=U?5õ f_aU <2Ãö :3Ãy

온라인으로 테스트하십시오!

파이썬 2 , 127 바이트

from random import*
s=['']*5
n=3
r=range(5)
exec"for i in r:s[i]+=' 0'[i==n]\nn=choice(r[n and~-n:n+2])\n"*30
print'\n'.join(s)

온라인으로 사용해보십시오!

통계 패키지가있는 옥타브 , 99 바이트

또한 MATLAB에서 Statistics Toolbox와 함께 작동합니다.

p=3;for k=1:29
p=[p;p(k)+fix(randsample(setdiff([1 pi 5],p(k)),1)-3)/2];end
disp(['' (p==1:5)'+32])

온라인으로 사용해보십시오!

apt , 28 바이트

ETH 프로덕션 덕분에 9 바이트 절약

3k
29Æp5õ f_aUgY)<2Ãö
¡QùXÃy

온라인으로 사용해보십시오!

SmileBASIC, 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

또한 길이가 같은 두 번째 줄의 변형을 발견했습니다.

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가 유효한 범위 밖에 있는지 확인하고 부호를 얻는 데 사용됩니다.

Java 8, 177170 바이트

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;}

@ OlivierGrégoire 덕분에 -7 바이트 .

설명:

온라인으로 사용해보십시오.

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

C (gcc) , 134130 바이트

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();}

온라인으로 사용해보십시오!

파이썬 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의 경우 중복 구문 분석 exec및 print제거가 가능하지만 두 번째 행의 구문은 유효하지 않습니다.

Rod에 의한 Py2 제출 과 linemade에 의한 Py3 제출 모두 아웃 고핑 .

루비 , 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싶었지만 문자열의 얕은 사본을 만들어 매우 뚱뚱하고 비석 매 뱀을 만들었습니다.

나는 D같은 바이트 수에 대해 증가 와 같은 상수를 사용할 수 있었지만 루비는 할당 할 때마다 불평했을 것입니다. i중간 루프를 재사용 하여 무시할 많은 디버그 경고를 갖는 것으로 가독성을 낮추는 것을 선호하기로 결정했습니다 .

나는 또한 몇 바이트를 절약하고 loop{x+=rand(3)-1;(0..4)===x&&break}싶었지만 가장자리에 편향이 생겼을 것입니다. 결국 무작위로 다시 걷기 전에 (즉, "숙박").

-20 바이트 : Ruby Integer#[]를 사용하여 작은 조건부를 작성하여 5 개 위치 모두에 대해 올바른 이동 가중치를 보장하십시오. 이는 막대한 비용 절감을 위해 루프 브레이크 패턴 (0이 아닌 중단 가능성으로)을 대체합니다. 고마워, Eric Duminil !

-1 바이트 : 초기화 a와 (0..4).map대신 5.times에 다시 한번 감사 에릭 Duminil .

->{
  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
}

펄 6 , 85 바이트

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

온라인으로 사용해보십시오!

긴 괄호로 묶인 표현식은 초기 요소에서 생성 된 게으른 시퀀스입니다. (' ', ' ', 0, ' ', ' ') 출력의 첫 번째 수직 스트립 인 입니다. 각각의 연속 스트립 / 목록은 그 호출 이전 하나로부터 생성 rotate임의로 포함하는 세트로부터 선택되는 오프셋과 함께, 방법 0, 1(첫 번째 요소가 0 인 경우), 및 -1(5 원소가 0 인 경우).

수평 스트립의 매트릭스는 [Z]오퍼레이터 와 함께 바뀌어 수직 스트립의 목록으로 바꾸고, 각각은 join단일 스트링으로 연결되고로 출력됩니다 say.

스칼라, 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)

견본:

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

디고 프드 :

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)

내 독창적 인 발명품-지금까지 다른 솔루션을 읽지 못했지만 암시 적으로 두 개의 랜덤 (2 * 3) 인 랜덤 (6)을 생성하는 것입니다. 경계에서 벗어나면 r / 2 (0,1,2) 및 → (-1,0,1) 값을 사용하여 위 또는 아래로 이동합니다. 국경에 있다면, 나는 다른 랜덤의 캐릭터 호출을 피할 수 있고, modulo (2)를 취하여, 내가 머물러야하는지, 아니면 가야하는지 결정합니다.

다른 솔루션을 보자. :)

펄, 83101 바이트

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'

언 골프 드 :

$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

PowerShell , 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$_}

온라인으로 사용해보십시오!

가로 30 칸, 세로 5 줄의 2D 배열을 구성합니다. (NB-누군가이 배열을 초기화하는 더 효과적인 방법을 생각해 낼 수 있다면, <3 당신을 영원히 기다릴 것입니다.) helper 변수 $l를 설정 합니다 2(이것은 이전 뱀 세그먼트가 어느 줄에 있었는지에 사용됩니다). 그런 다음에서 0로 반복 합니다 29.

반복 할 때마다 뱀 요소를로 설정합니다 0. 그런 다음 Get-Random위아래로 또는 동일하게 유지할지 여부를 선택 하는 복잡한 배열로 색인 합니다. 에 다시 추가되었습니다 $l.

마지막으로, 5 개의 요소 $a와 -join내부 요소를 각각 단일 문자열로 반복 합니다. 이 5 개의 줄은 파이프 라인에 남아 있으며 암시 적으로 Write-Output줄 바꿈을 무료로 제공합니다.

Clojure, 123 bytes

Here come the parens:

(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 version:

(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)))

Builds a list of the different heights of the snake body, then iterates from 0 to 4. Whenever a height matches the current row it prints a 0, otherwise a blank. Not letting the heights exceed the boundary really costs bytes. Also recognizing when a new line is in order is more byte-intensive as it should be. One could easily write a single doseq, making a cartesian product of the x's and y's but then one does not know when to print a new line.

Python3 +numpy, 137 132 bytes

Not the shortest python submission, not the longest, and definitely not the fastest.

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))

update Using numpy's diff command saved 5 bytes for testing if the snake is a valid pattern, compared to calculating the difference manually with j[1:]-j[:-1].

C (gcc), 80 76 72 71 bytes

a[5][30],i,r;f(){for(r=2;i<30;r+=rand()%3-1)a[r=r>4?4:r<0?0:r][i++]=1;}

Try it online!

R, 95 bytes

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

Next line x is always chosen from lines that are no more than 1 away from current line (l[abs(x-l)<2]). Using replicate instead of a for cycle saves some bytes needed for matrix initialization and manipulation and requires the use of the <<- operator when assigning to the global variable x.

Try it online!

05AB1E, 25 bytes

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

Try it online!

Explanation

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