Fortemente ispirato a questa sfida Code Golf: il tuo serpente ASCII da compagnia - pensavo che renderlo orizzontale avrebbe aggiunto un ulteriore livello di complessità.

Un esempio di serpente orizzontale:

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

E le regole sono:

1. Vengono stampate esattamente 5 righe di caratteri
2. Ogni riga ha esattamente 30 caratteri, costituita da una combinazione di spazi e dal personaggio con cui scegli di disegnare il tuo serpente
3. Il tuo serpente inizia alla linea 3
4. La linea successiva da usare per disegnare il tuo serpente deve essere scelta casualmente dalla linea corrente, una linea sopra (se non sei già sulla linea 1) o una linea sotto (se non sei già sulla linea 5).
   • Queste scelte devono essere equamente ponderate. Quindi, se sei sulla linea 1, hai una probabilità del 50% di rimanere sulla linea 1 e una probabilità del 50% di passare alla linea 2. Se sei sulla linea 2, hai una probabilità del 33% di passare alla linea 1, a Probabilità del 33% di rimanere sulla linea 2 o probabilità del 33% di spostarsi sulla linea 3
5. Il tuo serpente non ha bisogno di visitare ogni singola linea.

JavaScript (ES6), 98 byte

Salvato 7 byte grazie a @KevinCruijssen

Restituisce un array di 5 stringhe.

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

Provalo online!

Commentate

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

Carbone , 28 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

Ｐ|   

Stampa alcune imbottiture per forzare 5 righe di output.

Ｆ³⁰«

Ripeti 30 volte.

0

Stampa uno zero (e sposta in orizzontale).

≡ⅉ²Ｍ‽²↑

Se la coordinata Y è 2, spostati verso l'alto in modo casuale di 0 o 1.

±²Ｍ‽²↓

Se è -2, scorri verso il basso in modo casuale di 0 o 1.

Ｍ⊖‽³↓

Altrimenti spostati verso il basso in modo casuale di -1, 0 o 1.

Perl, 68 byte

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

Questo non sembra affatto ottimale.

Gelatina , 24 byte

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

Provalo online!

Spiegazione

3µ'o1r '«5 ¥ $ Xµ30СṬ € o⁶z⁶Y || Programma completo Niladic.
                         ||
3 || A partire da 3 ...
 µ µ30 || ... Eseguire 30 volte ...
               С || ... E raccogli i risultati in un elenco.
  'o1r' «5 ¥ $ X || - | Funzione "Helper" monadica.
  'o1 || - | L'intero corrente, decrementato O 1.
     r X || - | Prendi un oggetto a caso dall'intervallo da ^ a ...
      «« 5 || - | ... Il numero incrementato, limitato a 5 (utilizza il massimo).
         ¥ $ || - | Elementi di sintassi. Utilizzato per i collegamenti di raggruppamento.
                 Ṭ € || Non falso ciascuno.
                   o⁶ || OR logico con un singolo spazio.
                     z⁶ || Trasporre con spazi di riempimento.
                       Y || Unisciti a newline.

R , 138 byte

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

Provalo online!

Facilmente superato da plannapus

Python 3, 144 byte

@Ruts, @Turksarama e @mypetlion sono stati molto utili nel ridurre i byte

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)

Proverò a migliorarlo. Sfida divertente!

R , 120 114 byte

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

Grazie a @Giuseppe per i 6 byte aggiuntivi!

Utilizza una tabella di probabilità come segue:

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

dove ogni colonna corrisponde a un caso, ovvero la colonna 1 viene scelta se il serpente si trova nella riga 1, dando probabilità 0, 1/2 e 1/2 di scegliere rispettivamente -1 [vai giù], 0 [resta fermo] e 1 [ vai su] ( samplenormalizza automaticamente le probabilità su 1), la colonna 2 per la riga 2 fornisce le probabilità 1/3, 1/3 e 1/3, ecc ...

Provalo online!

SOGL V0.12 , 22 21 byte

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

Provalo qui!

Spiegazione:

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 byte

Restituisce una matrice di linee.

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

Provalo

Japt , 26 byte

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

Provalo online!

Python 2 , 127 byte

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)

Provalo online!

Ottava con pacchetto statistico, 99 byte

Funziona anche in MATLAB con la 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])

Provalo online!

Japt , 28 byte

Risparmio di 9 byte grazie a ETHproductions

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

Provalo online!

SmileBASIC, 107 105 103 89 byte

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

Questa risposta è più interessante di quella verticale a causa dei casi limite (letterali).

64 byte, senza spazi di stampa:

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

Ho anche trovato alcune varianti della linea 2 con la stessa lunghezza:

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 divisione intera di Y / 3 viene utilizzata per verificare se Y è al di fuori dell'intervallo valido, oltre a ottenere il segno.

Java 8, 177 170 byte

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 byte grazie a @ OlivierGrégoire .

Spiegazione:

Provalo online.

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 byte

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

Provalo online!

Python 3 , 123 byte

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

Provalo online!

Genera un array di numeri interi, quindi convertilo in ogni riga.

Python 2 , 120 byte

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)

Provalo online!

Per Py2, le parentesi ridondanti per exece printpossono essere rimosse, ma la sintassi nella seconda riga non è valida.

Superare sia la sottomissione Py2 di Rod sia la sottomissione Py3 di linemade .

Rubino , 98 77 byte

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

Provalo online!

Un lambda che restituisce una serie di stringhe.

Il mio impulso iniziale è stato quello di generare le colonne e trasporle, ma è molto più semplice evitare questo passaggio.

Mi sarebbe piaciuto per inizializzare acon [" "*30]*5, ma che sarebbe fare copie poco profonde delle corde, con un conseguente molto grasso, non viscido serpente.

Avrei potuto usare una costante come Dl'incremento (per lo stesso conteggio di byte), ma Ruby si sarebbe lamentato ogni volta che l'ho assegnato. Ho deciso che preferisco ridurre la leggibilità riutilizzando il iciclo intermedio rispetto a un sacco di avvisi di debug da ignorare.

Mi sarebbe piaciuto anche salvare qualche byte con loop{x+=rand(3)-1;(0..4)===x&&break}, ma ciò avrebbe causato una distorsione ai bordi: 1/3 possibilità di tornare indietro, 1/3 possibilità di rimanere e 1/3 possibilità di uscire dai limiti per un po 'prima di tornare a casaccio (ovvero "rimanere").

-20 byte: utilizzare Ruby Integer#[]per creare piccoli condizionali, garantendo ponderazioni di movimento corrette per tutte e 5 le posizioni. Questo sostituisce un modello di interruzione del ciclo (con una possibilità diversa da zero di non riuscire a fermarsi) per un enorme risparmio. Grazie Eric Duminil !

-1 byte: inizializza acon (0..4).mapinvece di 5.times, grazie ancora 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 byte

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

Provalo online!

L'espressione tra parentesi lunga è una sequenza pigra generata dall'elemento iniziale (' ', ' ', 0, ' ', ' '), la prima striscia verticale dell'output. Ogni striscia / elenco successiva viene generata dalla precedente chiamando il suo rotatemetodo, con l'offset scelto casualmente da un set contenente 0, 1(se il primo elemento è diverso da zero) e -1(se il quinto elemento è diverso da zero).

La matrice di strisce orizzontali viene trasposta con l' [Z]operatore, trasformandola in un elenco di strisce verticali, ognuna delle quali viene quindi joinedita in una singola stringa e emessa con say.

Scala, 207 byte

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)

campione:

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

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)

La mia invenzione unica - beh, finora non ho letto le altre soluzioni, è di generare un Casuale (6) che è implicitamente due Random, (2 * 3). Se lontano dal confine, uso i valori di r / 2 (0,1,2) e → (-1,0,1) per dirmi, per andare su o giù. Se al confine, posso evitare la costosa chiamata del personaggio di un altro casuale, e basta prendere il modulo (2), per decidere, se dovessi rimanere o dovrei andare.

Vediamo le altre soluzioni. :)

Perl, 83 101 byte

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'

Novità: senza problemi di probabilità ai confini:

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

PowerShell , 133 byte

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

Provalo online!

Costruisce una matrice 2D di 30 spazi di larghezza per 5 righe di altezza. (NB: se qualcuno può trovare un modo migliore per inizializzare questo array, ti <3 per sempre.) Imposta la variabile helper $lsu 2(questa è usata per la linea su cui si trovava il segmento precedente del serpente). Quindi 0passa da a 29.

Ad ogni iterazione, impostiamo il nostro elemento serpente su 0. Quindi indicizziamo in un array complicato Get-Randomche seleziona se andare su o giù o rimanere gli stessi. È stato aggiunto nuovamente in $l.

Infine, passiamo attraverso i cinque elementi $ae i -joinloro elementi interni in una singola stringa ciascuno. Quelle cinque stringhe vengono lasciate in cantiere e l'implicito Write-Outputci dà nuove linee gratis.

Clojure, 123 byte

Ecco i genitori:

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

Versione non golfata:

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

Crea un elenco delle diverse altezze del corpo del serpente, quindi scorre da 0 a 4. Ogni volta che un'altezza corrisponde alla riga corrente, stampa uno 0, altrimenti uno spazio vuoto. Non lasciare che le altezze superino il limite costa davvero byte. Anche riconoscere quando una nuova linea è in ordine richiede più byte come dovrebbe essere. Si potrebbe facilmente scrivere un singolodoseq , creando un prodotto cartesiano delle xe y ma non si sa quando stampare una nuova riga.

Python3 + numpy, 137 132 byte

Non il più breve invio di pitone, non il più lungo, e sicuramente non il più veloce.

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

aggiornamento Usando numpyil comando diff è stato salvato 5 byte per verificare se il serpente è un modello valido, rispetto al calcolo manuale della differenza con j[1:]-j[:-1].

C (gcc), 80 76 72 71 byte

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

Provalo online!

R , 95 byte

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 linea successiva xviene sempre scelta tra le linee che non distano più di 1 dalla linea corrente ( l[abs(x-l)<2]). L'uso al replicateposto di un forciclo consente di risparmiare alcuni byte necessari per l'inizializzazione e la manipolazione della matrice e richiede l'uso <<-dell'operatore durante l'assegnazione alla variabile globale x.

Provalo online!

05AB1E , 25 byte

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

Provalo online!

Spiegazione

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