Muy inspirado en este desafío Code Golf: tu propia serpiente ASCII mascota : pensé que hacerlo horizontal agregaría una capa adicional de complejidad.

Un ejemplo de serpiente horizontal:

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

Y las reglas son:

1. Se imprimen exactamente 5 líneas de caracteres
2. Cada línea tiene exactamente 30 caracteres, que consiste en una combinación de espacios y el personaje con el que eliges dibujar tu serpiente
3. Tu serpiente comienza en la línea 3
4. La siguiente línea que se utilizará para dibujar su serpiente debe elegirse al azar de su línea actual, una línea arriba (si aún no está en la línea 1) o una línea debajo (si aún no está en la línea 5).
   • Estas elecciones deben ser igualmente ponderadas. Entonces, si está en la línea 1, tiene un 50% de posibilidades de permanecer en la línea 1 y un 50% de posibilidades de pasar a la línea 2. Si está en la línea 2, tiene un 33% de posibilidades de pasar a la línea 1, un 33% de posibilidades de permanecer en la línea 2 o 33% de posibilidades de pasar a la línea 3
5. Su serpiente no necesita visitar cada línea.

JavaScript (ES6), 98 bytes

Guardado 7 bytes gracias a @KevinCruijssen

Devuelve una matriz de 5 cadenas.

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

Pruébalo en línea!

Comentado

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

Carbón , 28 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

Ｐ|   

Imprima un poco de relleno para forzar 5 líneas de salida.

Ｆ³⁰«

Repite 30 veces.

0

Imprima un cero (y muévalo horizontalmente).

≡ⅉ²Ｍ‽²↑

Si la coordenada Y es 2, suba aleatoriamente por 0 o 1.

±²Ｍ‽²↓

Si es -2, muévase hacia abajo al azar por 0 o 1.

Ｍ⊖‽³↓

De lo contrario, muévase hacia abajo aleatoriamente por -1, 0 o 1.

Perl, 68 bytes

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

Esto no se siente óptimo en absoluto.

Jalea , 24 bytes

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

Pruébalo en línea!

Explicación

3µ'o1r '«5 ¥ $ Xµ30СṬ € o⁶z⁶Y || Programa completo niladic.
                         ||
3 || A partir de 3 ...
 µ µ30 || ... Ejecutar 30 veces ...
               С || ... Y recoge los resultados en una lista.
  'o1r' «5 ¥ $ X || - | Función "Ayudante" monádica.
  'o1 || - | El entero actual, decrementado OR 1.
     r X || - | Coge un elemento aleatorio del rango de ^ a ...
      «« 5 || - | ... El número incrementado, limitado a 5 (usa el máximo).
         ¥ $ || - | Elementos de sintaxis. Utilizado para agrupar enlaces.
                 Ṭ € || No es verdad cada uno.
                   o⁶ || O lógico con un solo espacio.
                     z⁶ || Transponer con espacios de relleno.
                       Y || Únete por nuevas líneas.

R , 138 bytes

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

Pruébalo en línea!

Fácilmente superado por plannapus

Python 3, 144 bytes

@Ruts, @Turksarama y @mypetlion han sido muy útiles para reducir bytes

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)

Intentaremos mejorar esto. Desafío divertido!

R , 120 114 bytes

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

¡Gracias a @Giuseppe por los 6 bytes adicionales!

Utiliza una tabla de probabilidades de la siguiente manera:

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

donde cada columna corresponde a un caso, es decir, la columna 1 se elige si la serpiente está en la fila 1, dando las probabilidades 0, 1/2 y 1/2 para elegir respectivamente -1 [bajar], 0 [quedarse quieto] y 1 [ subir] ( samplenormaliza automáticamente las probabilidades a 1), la columna 2 para la fila 2 da las probabilidades 1/3, 1/3 y 1/3, etc.

Pruébalo en línea!

SOGL V0.12 , 22 21 bytes

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

Pruébalo aquí!

Explicación:

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

Japt, 31 29 bytes

Devuelve una matriz de líneas.

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

Pruébalo

Japt , 26 bytes

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

¡Pruébalo en línea!

Python 2 , 127 bytes

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)

Pruébalo en línea!

Octava con paquete de estadísticas, 99 bytes

También funciona en MATLAB con 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])

Pruébalo en línea!

Japt , 28 bytes

Guardado 9 bytes gracias a ETHproductions

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

Pruébalo en línea!

SmileBASIC, 107 105 103 89 bytes

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

Esta respuesta es más interesante que la vertical debido a los casos límite (literales).

64 bytes, sin espacios de impresión:

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

También encontré algunas variaciones de la línea 2 con la misma longitud:

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

La división entera de Y / 3 se usa para verificar si Y está fuera del rango válido, así como para obtener el signo.

Java 8, 177 170 bytes

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 bytes gracias a @ OlivierGrégoire .

Explicación:

Pruébalo en línea.

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) , 134 130 bytes

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

Pruébalo en línea!

Python 3 , 123 bytes

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

Pruébalo en línea!

Genere una matriz de enteros, luego conviértalo a cada fila.

Python 2 , 120 bytes

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)

Pruébalo en línea!

Para Py2, los pares redundantes para execy printse pueden eliminar, pero la sintaxis en la segunda línea no es válida.

Superando tanto el envío de Py2 por Rod como el envío de Py3 por linemade .

Ruby , 98 77 bytes

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

Pruébalo en línea!

Una lambda que devuelve una serie de cadenas.

Mi impulso inicial fue generar las columnas y transponerlas, pero es mucho más fácil evitar ese paso.

Me hubiera gustado comenzar acon [" "*30]*5, pero eso haría copias superficiales de las cadenas, lo que resultaría en una serpiente muy gruesa y no resbaladiza.

Podría haber usado una constante Dcomo el incremento (para el mismo conteo de bytes), pero Ruby se habría quejado cada vez que lo asignaba. Decidí que prefiero disminuir la legibilidad al reutilizar imid-loop que tener un montón de advertencias de depuración para ignorar.

También me hubiera gustado guardar algunos bytes con loop{x+=rand(3)-1;(0..4)===x&&break}, pero eso habría causado un sesgo en los bordes: 1/3 de posibilidad de volver hacia adentro, 1/3 de posibilidad de quedarse y 1/3 de posibilidad de salir de los límites para un tiempo antes de volver al azar al azar (es decir, "quedarse").

-20 bytes: use Ruby Integer#[]para crear condicionales pequeños, asegurando ponderaciones de movimiento correctas para las 5 posiciones. Esto reemplaza un patrón de ruptura de bucle (con una probabilidad distinta de cero de no detenerse) por un gran ahorro. Gracias Eric Duminil !

-1 byte: Inicialice acon en (0..4).maplugar de 5.times, gracias de nuevo a Eric 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
}

Perl 6 , 85 bytes

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

Pruébalo en línea!

La expresión larga entre paréntesis es una secuencia perezosa generada a partir del elemento inicial (' ', ' ', 0, ' ', ' '), la primera franja vertical de la salida. Cada tira / lista sucesiva se genera a partir de la anterior llamando a su rotatemétodo, con el desplazamiento elegido aleatoriamente de un conjunto que contiene 0, 1(si el primer elemento es distinto de cero) y -1(si el quinto elemento es distinto de cero).

La matriz de tiras horizontales se transpone con el [Z]operador, convirtiéndola en una lista de tiras verticales, cada una de las cuales se joinedita en una sola cadena y se genera con say.

Scala, 207 Bytes

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)

muestra:

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

degolfado:

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)

Mi invento único: bueno, hasta ahora no he leído las otras soluciones, es generar un Random (6) que implícitamente son dos Randoms (2 * 3). Si está lejos del borde, uso los valores de r / 2 (0,1,2) y → (-1,0,1) dime, para subir o bajar. Si en la frontera, puedo evitar la costosa llamada del personaje de otro azar, y simplemente tomar el módulo (2), para decidir, si me quedo o si me voy.

Veamos las otras soluciones. :)

Perl, 83 101 bytes

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'

Nuevo: Sin problema de probabilidad en las fronteras:

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'

Sin golf:

$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 bytes

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

Pruébalo en línea!

Construye una matriz 2D de 30 espacios de ancho por 5 líneas de alto. (Nota: si alguien puede encontrar una forma mejor y efectiva de inicializar esta matriz, te <3 para siempre.) Establece la variable auxiliar $len 2(esto se usa para qué línea estaba el segmento de serpiente anterior). Luego recorre de 0a 29.

En cada iteración, establecemos nuestro elemento serpiente en 0. Luego indexamos en una matriz complicada Get-Randomque selecciona si subimos o bajamos o nos mantenemos igual. Eso se agrega de nuevo a $l.

Finalmente, recorremos los cinco elementos $ay -joinsus elementos internos en una sola cadena cada uno. Esas cinco cadenas quedan en la tubería, y lo implícito Write-Outputnos da nuevas líneas de forma gratuita.

Clojure, 123 bytes

Aquí vienen los 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)))

Versión sin golf:

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

Construye una lista de las diferentes alturas del cuerpo de la serpiente, luego itera de 0 a 4. Cada vez que una altura coincide con la fila actual, imprime un 0, de lo contrario, un espacio en blanco. No dejar que las alturas excedan el límite realmente cuesta bytes. También reconocer cuándo una nueva línea está en orden requiere más byte como debería ser. Uno podría escribir fácilmente un sencillo doseq, haciendo un producto cartesiano de las X e Y, pero no se sabe cuándo imprimir una nueva línea.

Python3 + numpy, 137 132 bytes

No es la presentación de Python más corta, no es la más larga y definitivamente no es la más rápida.

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

actualizar El uso numpydel comando diff ahorró 5 bytes para probar si la serpiente es un patrón válido, en comparación con el cálculo manual de la diferencia 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;}

Pruébalo en línea!

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

La siguiente línea xsiempre se elige entre las líneas que no están a más de 1 de la línea actual ( l[abs(x-l)<2]). El uso en replicatelugar de un forciclo ahorra algunos bytes necesarios para la inicialización y manipulación de la matriz y requiere el uso del <<-operador al asignar a la variable global x.

Pruébalo en línea!

05AB1E , 25 bytes

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

Pruébalo en línea!

Explicación

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