Então, eu escrevi para mim uma linha que imprimiu uma cobra no console. É um pouco divertido, e me perguntei como poderia condensar meu código ...

Aqui está um exemplo (curto) de saída:

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

Aqui estão as especificações:

• Em cada linha, um único caractere que não seja um espaço em branco (o que você quiser) é impresso no console, inicialmente com 29 a 31 espaços preenchidos à esquerda dele.
• A cada iteração, é tomada uma decisão aleatória entre essas três ações
  • A quantidade de preenchimento diminui em 1
  • A quantidade de preenchimento permanece a mesma
  • A quantidade de preenchimento aumenta em 1

Faça isso 30 vezes, para imprimir uma cobra de 30 segmentos no console.

A resposta mais curta em bytes vence.

05AB1E , 15 14 bytes

30DF2Ý<+ΩD0sú,

Experimente online!

Usos 0.

Explicação

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

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

Experimente online!

O Random Brainfuck é uma extensão do brainfuck, com a adição útil do ?comando, que define a célula atual para um byte aleatório. Isso imprime uma cobra feita de !s, que se parece mais com passos do que com uma cobra de maneira engraçada.

Como 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

Outra solução que adere à letra da pergunta, e não ao espírito.

87 bytes

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

Experimente online!

Este é fortemente inclinado para deixar o preenchimento sozinho, mas aumentar ou diminuir o preenchimento são igualmente possíveis. Cada um tem uma chance ligeiramente menor que 1 em 256 de acontecer.

C (gcc) , 61 58 56 bytes

Resposta editada para refletir as alterações das regras ...

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

Experimente online!

Retina , 24 bytes

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

Experimente online!

Explicação

30* +

Inicialize a string de trabalho na primeira linha, ou seja, 30 espaços e a +.

-29{¶<`^
 

Há um espaço na segunda linha. -29{quebra o restante do programa em um loop, que é executado 29 vezes. ¶<imprime a sequência de trabalho no início de cada iteração do loop com um avanço de linha à direita. O próprio estágio atômico insere um espaço no início da string (a idéia básica é inserir um espaço e, em seguida, remover aleatoriamente de 0 a 2 espaços, porque esse é um byte mais curto do que escolher aleatoriamente entre exclusão, inserção e não operação).

S,2@1`

Isso corresponde ao regex vazio em relação à entrada, o que nos dá todas as posições entre os caracteres (e o início e o fim da string). Em seguida, ,2mantém apenas as três primeiras partidas, ou seja, as partidas após zero, um e dois espaços. @seleciona uma aleatória dessas três correspondências. Em seguida, o estágio dividido ( S) divide a entrada em torno dessa correspondência. E o 1diz para manter apenas a segunda parte da divisão. Em outras palavras, descartamos tudo até nossa correspondência aleatória.

A 30ª linha, que é o resultado da iteração final do loop, é impressa implicitamente no final do programa.

VBA, 60 59 49 bytes

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

Cole-o na janela Immediate e pressione enter. (Verifique se a declaração explícita está desativada!)

Muito mais probabilidade de se mover do que de permanecer em uma linha (ou seja, as ações não têm o mesmo peso), mas esse não era um requisito especificado (felizmente!)

{EDIT} Economizou 1 byte removendo o espaço entre =1eTo

{EDIT2} salvou 10 bytes graças ao comentário de remoel

Versões antigas:

'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 graças a @raznagul .
-1 byte graças a @auhmaan .

Explicação:

Experimente online.

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

Experimente online!

Explicação:

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 f "retornar" o valor atribuído a n na função, que é um comportamento indefinido, mas funciona de forma consistente com o gcc quando nenhuma otimização é ativada.

Experimente online!

JavaScript (ES8), 63 62 60 bytes

Inclui uma nova linha à direita. *2-1poderia ser substituído -.5por uma economia de 1 byte, mas as chances de cada linha ter o mesmo comprimento que a linha anterior aumentariam bastante. Obviamente, como "aleatório" não é definido no desafio, o RNG pode ser substituído new Date%3-1por uma contagem total de 55 bytes .

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

Salvei um byte graças a alguém que excluiu seu comentário antes que eu pudesse pegar o nome. Na verdade, eu tentei dessa maneira repeate padStartnão pensei em tentar padEnd- não sei por que!

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

<pre id=o>

Bônus

Para o mesmo número de bytes, aqui está uma versão que usa como entrada o número de espaços e iterações iniciais.

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

Primeiro golfe, tenho certeza que poderia ser muito melhor ..

Edit: primeira linha fixa graças ao Steadybox .

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

Experimente online!

 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

Abordagem direta:

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

Experimente online!

Obrigado ao @Rod por salvar alguns bytes! Obrigado a @ovs por -1 byte!

Editar: nome da variável alterada e sequência de saída para a letra 's'

Mais saída de cobra 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 salvo graças a ngn

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

Experimente online!

Carvão , 14 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

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

Seriam apenas 10 bytes se não houvesse um requisito de recuo inicial.

PHP, 61 bytes

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

Experimente online!

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

Explicação:

Experimente online.

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

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

Explicação:

Experimente online.

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

Obrigado a Zahiro Mor por 2 bytes extras!

Experimente online!

Japonês , 13 bytes

Retorna uma matriz de linhas.

30ÆQù1nH±1n3ö

Teste-o

Explicação

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

Bônus

Por 2 bytes a menos , aqui está uma versão que usa como entrada o número de espaços e iterações iniciais.

U°ÆQùU±1n3ö

Tente

RNGs alternativos

Os últimos 4 bytes podem ser substituídos por qualquer um dos seguintes:

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

Rápido , 101 bytes

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

Explicação

Um programa completo. Isso usa um truque bastante estranho: arc4random()é um membro do Darwinmódulo, mas UIKittambém vem com esta função instalada, por isso economiza um byte :) Também usa uma das minhas dicas de golfe do Swift para repetir seqüências de caracteres várias vezes.

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

Idéia semelhante à anterior , mas com sprintfcódigo abreviado e uma cadeia de caracteres mais curta literal. Em vez de \n(dois bytes), estou usando uma quebra de linha literal (um byte).

Try it online!

Ruby , 45 39 bytes

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

Experimente online!

Modificar xdurante o loop não afeta o contador de loops. Eu escolhi S como um caractere de saída particularmente semelhante a uma cobra.

-6 bytes: use em rand(3)-1vez de [-1,0,1].sample. Obrigado, Eric Duminil !

SenseTalk , 237 198 bytes

Essa é uma linguagem que conheci e amei cerca de uma década atrás. É a linguagem de script que aciona a ferramenta de teste automatizada Eggplant Functional . Eu era um usuário ávido da ferramenta por muitos anos antes de ingressar na empresa por um tempo. Não é a língua com maior capacidade de golfe, mas acho muito agradável escrever. Jogar golfe é realmente bastante desafiador, pois o idioma deve ser detalhado e parecido com o inglês ... demorei um pouco para entender para 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 / Explicação

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

Edit: Salvo 36 bytes graças a @mustachemoses

J , 23 bytes

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

Experimente online!

PowerShell , 42 bytes

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

Experimente online!

Loops de 1para $l=30. A cada iteração, colocamos $lespaços mais um xno pipeline como uma string e, em seguida, +=baseamos -1, 0, 1em Get-Randomno $lpróximo loop. Essas strings são coletadas do pipeline e um implícito Write-Outputnos fornece uma lista separada por nova linha gratuitamente.

Bash, 53

• 3 bytes salvos graças a @Dennis

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

Experimente online .

Gelatina , 18 bytes

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

Experimente online!

O caractere escolhido é 0 . Se o retorno de uma lista de caracteres for permitido, ele Ypoderá ser descartado e o envio poderá ser transformado em uma cadeia niládica por 17 bytes . Alternativa .

Como funciona

€ 0Y | Link principal niládico.
30 A partir de 30 ...
  Ç'С ... Repita o link auxiliar 29 vezes e colete os resultados em uma lista.
             | (Esta lista inclui os 30 primeiros, então, na verdade, existem 30 números).
      ⁶ẋ Repita um espaço várias vezes para cada item da lista.
        0 € | Anexe um 0 a cada um.
           Y E junte-se por novas linhas.
------------- +
1ŒRX + | Link auxiliar monádico. Como alternativa, você pode usar µ1 × RX + µ em vez de Ç.
1 | O literal.
 |R | Faixa simétrica de –1 a 1.
   X + Escolha um número aleatório e adicione-o ao argumento.

Gelatina , 16 bytes

Combinando as minhas, as soluções de Erik e Jonathan, podemos jogar até 16 bytes. O personagem escolhido é 1 .

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

Experimente online!

Obrigado a Jonathan Allan pelo heads-up (em Ṭ€o⁶).

Oitava , 53 51 50 49 bytes

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

Experimente online!

Salvo 1 byte, não fazendo mais nenhum loop. Salvei outro como o Octave printftambém fprintf.

Esse novo código cria uma matriz de 30 números inteiros aleatórios no intervalo -1:1. Em seguida, soma cumulativamente a matriz e adiciona 30, o que fornece a sequência desejada.

O resultado é impresso usando fprintfum formato que diz "Um número decimal, preenchido com uma largura especificada, seguido por uma nova linha. A largura será a primeira entrada de valor e o número decimal será a segunda entrada de valor. Se o número dos valores introduzidos é mais do que isso, o Octave continuará repetindo a impressão automaticamente para obter a saída desejada.

Para obter o loop, precisamos apenas intercalar zeros entre a matriz de sequências, para que a fprintffunção use cada valor na sequência como uma largura e cada zero como o dígito a ser impresso.

Imprime uma saída 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

O código acima nem sempre imprime exatamente 30 espaços na primeira linha. Será 29, 30 ou 31. Para corrigir isso, você usaria esta versão 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

for i=1,n ...Na to_exp n é avaliada apenas uma vez antes de entrar no loop, economizando um byte.

-6 graças a @ user202729

Experimente online!

Python 3.6 , 84 73 69 bytes

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

Graças a @WheatWizard por -11 bytes. Graças 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 se for necessário o formato da função:

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

Vermelho , 54 bytes

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

Experimente online!