Entonces, escribí una línea que imprimía una serpiente en la consola. Es un poco divertido, y me preguntaba cómo podría condensar mi código ...

Aquí hay una salida de ejemplo (corta):

                +
                 +
                  +
                   +
                   +
                   +
                  +
                   +
                    +
                    +
                    +
                     +
                     +
                      +
                      +
                       +
                      +
                     +
                     +
                    +

Aquí están las especificaciones:

• En cada línea, se imprime un único carácter que no sea un espacio en blanco (lo que desee) en la consola, inicialmente con 29 a 31 espacios de relleno a la izquierda de la misma.
• Cada iteración, se toma una decisión aleatoria entre estas tres acciones
  • La cantidad de relleno disminuye en 1
  • La cantidad de relleno sigue siendo la misma.
  • La cantidad de relleno aumenta en 1

Haga esto 30 veces, para imprimir una serpiente de 30 segmentos en la consola.

La respuesta más corta en bytes gana.

05AB1E , 15 14 bytes

30DF2Ý<+ΩD0sú,

Pruébalo en línea!

Usos 0.

Explicación

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

Random Brainfuck , 123 122 121 bytes

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

Pruébalo en línea!

Brainfuck aleatorio es una extensión de brainfuck, con la útil adición del ?comando, que establece la celda actual en un byte aleatorio. Esto imprime una serpiente hecha de !s, que se parece más a los pasos que a una serpiente curiosamente.

Cómo funciona:

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

Otra solución que se adhiere a la letra de la pregunta, en lugar del espíritu.

87 bytes

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

Pruébalo en línea!

Este está muy sesgado para dejar el relleno solo, pero aumentar o disminuir el relleno es igualmente posible. Cada uno tiene un poco menos de 1 en 256 posibilidades de suceder.

C (gcc) , 61 58 56 bytes

Respuesta editada para reflejar cambios en las reglas ...

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

Pruébalo en línea!

Retina , 24 bytes

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

Pruébalo en línea!

Explicación

30* +

Inicialice la cadena de trabajo a la primera línea, es decir, 30 espacios y a +.

-29{¶<`^
 

Hay un espacio en la segunda línea. -29{envuelve el resto del programa en un bucle, que se ejecuta 29 veces. ¶<imprime la cadena de trabajo al comienzo de cada iteración de bucle con un salto de línea final. La etapa atómica en sí misma inserta un espacio al comienzo de la cadena (la idea básica es insertar un espacio y luego eliminar aleatoriamente 0–2 espacios, porque es un byte más corto que elegir aleatoriamente entre eliminar, insertar y no operar).

S,2@1`

Esto coincide con la expresión regular vacía contra la entrada, lo que nos da cada posición entre los caracteres (y el inicio y el final de la cadena). Luego ,2mantiene solo los primeros tres partidos, es decir, los partidos después de cero, uno y dos espacios. @selecciona uno aleatorio de esos tres partidos. Luego, la etapa dividida ( S) divide la entrada alrededor de esa coincidencia. Y 1le dice que mantenga solo la segunda parte de la división. En otras palabras, descartamos todo hasta nuestra coincidencia aleatoria.

La línea 30, que es el resultado de la iteración final del bucle, se imprime implícitamente al final del programa.

VBA, 60 59 49 bytes

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

Pégalo en la ventana Inmediato y presiona enter. (¡Asegúrese de que la declaración explícita esté desactivada!)

Es mucho más probable que se mueva que permanecer en una línea (es decir, las acciones no tienen la misma ponderación), pero ese no era un requisito específico (¡Afortunadamente!)

{EDITAR} Guardado 1 byte eliminando el espacio entre =1yTo

{EDIT2} Guardado 10 bytes gracias al comentario de remoel

Versiones antiguas:

'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

C # (.NET Core), 112 110 106 100 99 98 bytes

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

-1 byte gracias a @raznagul .
-1 byte gracias a @auhmaan .

Explicación:

Pruébalo en línea.

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

C, 56 bytes

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

Pruébalo en línea!

Explicación:

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

C (gcc) , 55 bytes

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

Depende de que f "devuelva" el valor asignado a n en la función, que es un comportamiento indefinido, pero funciona de manera coherente con gcc cuando no se habilitan optimizaciones.

Pruébalo en línea!

JavaScript (ES8), 63 62 60 bytes

Incluye una nueva línea final. *2-1podría reemplazarse -.5por un ahorro de 1 byte, pero las posibilidades de que cada línea tenga la misma longitud que la línea anterior aumentaría considerablemente. Por supuesto, como "aleatorio" no está definido en el desafío, el RNG podría ser reemplazado pornew Date%3-1 por un recuento total de bytes de 55 .

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

Ahorré un byte gracias a alguien que eliminó su comentario antes de que pudiera captar el nombre. En realidad lo intenté de esta manera repeaty padStartno pensé en intentarlo padEnd, ¡no sé por qué!

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

<pre id=o>

Prima

Para el mismo número de bytes, aquí hay una versión que toma el número de espacios e iteraciones iniciales como entrada.

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>

Java 8, 89 87 bytes

Primero golf, estoy seguro de que podría ser mucho mejor ...

Editar: se corrigió la primera línea gracias a Steadybox .

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

Pruébalo en línea!

 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
    }

Python 2 , 83 65 64 bytes

Enfoque directo:

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

Pruébalo en línea!

¡Gracias a @Rod por guardar algunos bytes! ¡Gracias a @ovs por -1 byte!

Editar: cambió el nombre de la variable y la cadena de salida a la letra 's'

Más salida tipo serpiente para 88 bytes:

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

APL (Dyalog) , 20 bytes

1 byte guardado gracias a ngn

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

Pruébalo en línea!

Carbón , 14 bytes

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

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

× ³⁰            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

Sería de solo 10 bytes si no hubiera un requisito de sangría inicial.

PHP, 61 bytes

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

Pruébalo en línea!

Java 8, 131 129 127 126 119 108 101 bytes

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

Explicación:

Pruébalo en línea.

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

Antigua respuesta de 119 bytes:

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

Explicación:

Pruébalo en línea.

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

R , 72 69 67 bytes

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

Gracias a Zahiro Mor por 2 bytes adicionales!

Pruébalo en línea!

Japt , 13 bytes

Devuelve una matriz de líneas.

30ÆQù1nH±1n3ö

Pruébalo

Explicación

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

Prima

Para 2 bytes menos , aquí hay una versión que toma la cantidad de espacios e iteraciones iniciales como entrada.

U°ÆQùU±1n3ö

Intentalo

RNG alternativos

Los últimos 4 bytes se pueden reemplazar con cualquiera de los siguientes:

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

Swift , 101 bytes

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

Explicación

Un programa completo Esto usa un truco bastante extraño: arc4random()es miembro del Darwinmódulo, pero UIKittambién viene con esta función instalada, por lo que guarda un byte :) También usa uno de mis consejos de golf Swift para repetir cadenas un número arbitrario de veces.

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

Perl, 36 bytes

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

R 54 53 bytes

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

Idea similar a la anterior , pero con sprintfcódigo acortado y una cadena de caracteres literal más corta. En lugar de \n(dos bytes) estoy usando un salto de línea literal (un byte).

Try it online!

Ruby , 45 39 bytes

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

Pruébalo en línea!

La modificación xdurante el ciclo no afecta al contador del ciclo. Elegí S como un personaje de salida particularmente parecido a una serpiente.

-6 bytes: uso en rand(3)-1lugar de [-1,0,1].sample. Gracias Eric Duminil !

SenseTalk , 237 198 Bytes

Este es un lenguaje que llegué a conocer y amar hace una década. Es el lenguaje de secuencias de comandos que impulsa la herramienta de prueba automatizada Eggplant Functional . Fui un ávido usuario de la herramienta durante muchos años antes de unirme a la empresa por un tiempo. No es el idioma más apto para el golf, pero me resulta muy divertido escribirlo. Jugar al golf en realidad es bastante desafiante, ya que el idioma debe ser detallado y similar al inglés ... me llevó bastante tiempo entenderlo. a 237 bytes.

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 / Explicación

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

Editar: Guardado 36 bytes gracias a @mustachemoses

J , 23 bytes

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

Pruébalo en línea!

PowerShell , 42 bytes

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

Pruébalo en línea!

Bucles de 1a $l=30. En cada iteración, colocamos $lespacios más un xen la tubería como una cadena, luego, +=ya sea en -1, 0, 1base Get-Randomal $lsiguiente ciclo. Esas cadenas se recopilan de la tubería y un implícito Write-Outputnos da una lista separada por una nueva línea de forma gratuita.

Bash, 53

• 3 bytes guardados gracias a @Dennis

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

Pruébalo en línea .

Jalea , 18 bytes

1ŒRX+
30ǒС⁶ẋ;€0Y

Pruébalo en línea!

El personaje elegido es 0 . Si se permite devolver una lista de la lista de caracteres, entonces elY puede descartar y el envío se puede convertir en una cadena niládica de 17 bytes . Alternativa .

Cómo funciona

30Ç'С⁶ẋ; € 0Y | Enlace principal de Niladic.
30 A partir de 30 ...
  Ç'С | ... Repita el enlace auxiliar 29 veces y recopile los resultados en una lista.
             El | (Esta lista incluye los primeros 30, por lo que en realidad hay 30 números).
      ⁶ẋ | Repita un espacio tantas veces, para cada elemento de la lista.
        ; € 0 | Agregue un 0 a cada uno.
           Y | Y únete por nuevas líneas.
------------- +
1ŒRX + | Enlace auxiliar monádico. Alternativamente, puede usar µ1ŒRX + µ en lugar de Ç.
1 | El literal
 ŒR | Rango simétrico de –1 a 1.
   X + | Elija un número aleatorio y agréguelo al argumento.

Jalea , 16 bytes

Combinando las soluciones mías, de Erik y Jonathan, podemos reducir esto a 16 bytes. El personaje elegido es 1 .

’r‘X
30ǒСṬ€o⁶Y

Pruébalo en línea!

Gracias a Jonathan Allan por el heads-up (encendido Ṭ€o⁶).

Octava , 53 51 50 49 bytes

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

Pruébalo en línea!

Guardado 1 byte al no hacer más bucles. Salvó a otro como Octave printftambién fprintf.

Este nuevo código crea una matriz de 30 enteros aleatorios en el rango -1:1. Luego suma acumulativamente la matriz y agrega 30, lo que da la secuencia deseada.

El resultado se imprime fprintfcon un formato que dice "Un número decimal, rellenado con un ancho especificado, seguido de una nueva línea. El ancho será el primer valor ingresado y el número decimal será el segundo valor ingresado. Si el número de entrada de valores es más que esto, Octave seguirá repitiendo la impresión automáticamente para obtener la salida deseada.

Para lograr el bucle, entonces, solo necesitamos intercalar ceros entre la matriz de secuencia para que la fprintffunción use cada valor en la secuencia como un ancho, y cada cero como el dígito a imprimir.

Imprime una salida como:

                              0
                             0
                              0
                             0
                              0
                               0
                              0
                               0
                              0
                              0
                             0
                            0
                           0
                           0
                           0
                          0
                           0
                            0
                             0
                              0
                              0
                             0
                             0
                              0
                               0
                              0
                              0
                               0
                               0
                                0

El código anterior no siempre imprime exactamente 30 espacios en la primera línea. Será 29, 30 o 31. Para corregir eso, usaría esta versión de 53 bytes:

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

Lua 81 75 bytes

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

En for i=1,n ...el to_exp n se evalúa sólo una vez antes de entrar en el bucle, el ahorro de un byte.

-6 gracias a @ user202729

Pruébalo en línea!

Python 3.6 , 84 73 69 bytes

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

Gracias a @WheatWizard por -11 bytes. Gracias a @JoKing por -4 bytes.

ES5, 97 95 81 bytes

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

ES5, 11298 bytes si se necesita el formato de función:

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

Rojo , 54 bytes

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

Pruébalo en línea!