Więc napisałem sobie jedno-linijkę, która wydrukowała węża na konsoli. To trochę zabawne i zastanawiałem się, jak mogę skondensować kod ...

Oto (krótki) przykładowy wynik:

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

Oto specyfikacje:

• W każdym wierszu na konsoli drukowany jest pojedynczy znak spacji (w zależności od tego, co chcesz), początkowo z 29 do 31 spacjami po lewej stronie.
• Przy każdej iteracji pomiędzy tymi trzema akcjami podejmowana jest losowa decyzja
  • Ilość wypełnienia zmniejsza się o 1
  • Ilość wypełnienia pozostaje taka sama
  • Ilość wypełnienia wzrasta o 1

Zrób to 30 razy, aby wydrukować węża o długości 30 segmentów na konsolę.

Najkrótsza odpowiedź w bajtach wygrywa.

05AB1E , 15 14 bajtów

30DF2Ý<+ΩD0sú,

Wypróbuj online!

Zastosowania 0.

Wyjaśnienie

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 bajtów

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

Wypróbuj online!

Random Brainfuck jest rozszerzeniem „brainfuck”, z pomocnym dodatkiem ?polecenia, które ustawia bieżącą komórkę na losowy bajt. To drukuje węża wykonanego z !s, który bardziej zabawnie przypomina kroki.

Jak to działa:

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

Inne rozwiązanie, które przylgnie do litery pytania, a nie ducha.

87 bajtów

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

Wypróbuj online!

Ten jest mocno tendencyjny do pozostawiania wyściółki w spokoju, ale zwiększenie lub zmniejszenie wyściółki są równie możliwe. Każda z nich ma nieco mniej niż 1 na 256 okazji.

C (gcc) , 61 58 56 bajtów

Odpowiedź edytowana w celu odzwierciedlenia zmian zasad ...

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

Wypróbuj online!

Siatkówka , 24 bajty

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

Wypróbuj online!

Wyjaśnienie

30* +

Zainicjuj łańcuch roboczy do pierwszego wiersza, tj. 30 spacji i znaku a +.

-29{¶<`^
 

W drugiej linii jest spacja. -29{opakowuje pozostałą część programu w pętlę, która jest uruchamiana 29 razy. ¶<wypisuje ciąg roboczy na początku każdej iteracji pętli z końcowym przesuwem linii. Sam etap atomowy wstawia spację na początku łańcucha (podstawową ideą jest wstawienie jednej spacji, a następnie losowe usunięcie 0–2 spacji, ponieważ jest to bajt krótszy niż losowe wybieranie między usuwaniem, wstawianiem i brakiem operacji).

S,2@1`

Odpowiada to pustemu wyrażeniu regularnemu względem danych wejściowych, co daje nam każdą pozycję między znakami (oraz początkiem i końcem łańcucha). Następnie ,2zachowuje tylko trzy pierwsze dopasowania, tzn. Dopasowania po zera, jeden i dwa spacje. @wybiera losowy jeden z tych trzech dopasowań. Następnie etap podziału ( S) dzieli dane wejściowe wokół tego dopasowania. I 1każe zachować tylko drugą część podziału. Innymi słowy, odrzucamy wszystko, aż do losowego dopasowania.

30. linia, która jest wynikiem końcowej iteracji pętli, jest drukowana domyślnie na końcu programu.

VBA, 60 59 49 bajtów

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

Wklej go w oknie Natychmiastowe i naciśnij klawisz Enter. (Upewnij się, że wyraźna deklaracja jest wyłączona!)

O wiele bardziej prawdopodobne jest, że poruszy się niż pozostanie w linii (tzn. Akcje nie są równo ważone), ale nie był to określony wymóg (na szczęście!)

{EDYCJA} Zaoszczędzono 1 bajt, usuwając spację między =1iTo

{EDIT2} Zaoszczędzono 10 bajtów dzięki komentarzowi Remoela

Stare wersje:

'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 bajtów

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

-1 bajt dzięki @raznagul .
-1 bajt dzięki @auhmaan .

Wyjaśnienie:

Wypróbuj 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 bajtów

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

Wypróbuj online!

Wyjaśnienie:

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 bajtów

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

Zależy od f „powrotu” wartości przypisanej nw funkcji, co jest niezdefiniowanym zachowaniem, ale działa spójnie z gcc, gdy nie są włączone optymalizacje.

Wypróbuj online!

JavaScript (ES8), 63 62 60 bajtów

Zawiera końcowy znak nowej linii. *2-1można by zastąpić -.51 bajtem oszczędności, ale szanse, że każda linia będzie miała taką samą długość jak poprzednia linia, znacznie wzrosłyby. Oczywiście, ponieważ „wyzwanie” nie jest zdefiniowane w wyzwaniu, RNG można zastąpić new Date%3-1całkowitą liczbą bajtów wynoszącą 55 .

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

Zapisałem bajt dzięki komuś, kto usunął swój komentarz, zanim mogłem złapać nazwę. Ja rzeczywiście starał się to w ten sposób repeat, a padStartjednak nie sądzę, aby spróbować padEnd- nie wiem dlaczego!

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

<pre id=o>

Premia

Dla tej samej liczby bajtów, oto wersja, która przyjmuje liczbę początkowych spacji i iteracji jako dane wejściowe.

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 bajtów

Najpierw golf, jestem pewien, że mogłoby być znacznie lepiej ..

Edycja: Naprawiono pierwszą linię dzięki Steadybox .

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

Wypróbuj 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 bajtów

Proste podejście:

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

Wypróbuj online!

Dzięki @Rod za uratowanie niektórych bajtów! Dzięki @ovs za -1 bajt!

Edycja: zmieniono nazwę zmiennej i ciąg wyjściowy na literę „s”

Więcej wężowych danych wyjściowych dla 88 bajtów:

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

APL (Dyalog) , 20 bajtów

1 bajt zapisany dzięki ngn

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

Wypróbuj online!

Węgiel drzewny , 14 bajtów

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

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

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

Byłby tylko 10 bajtów, gdyby nie było wymogu wstępnego wcięcia.

PHP, 61 bajtów

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

Wypróbuj online!

Java 8, 131 129 127 126 119 108 101 bajtów

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

Wyjaśnienie:

Wypróbuj 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

Stara 119 bajtowa odpowiedź:

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

Wyjaśnienie:

Wypróbuj 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 bajtów

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

Dzięki Zahiro Mor za 2 dodatkowe bajty!

Wypróbuj online!

Japt , 13 bajtów

Zwraca tablicę wierszy.

30ÆQù1nH±1n3ö

Sprawdź to

Wyjaśnienie

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

Premia

Dla 2 bajtów mniej , oto wersja, która przyjmuje liczbę początkowych spacji i iteracji jako dane wejściowe.

U°ÆQùU±1n3ö

Spróbuj

Alternatywne RNG

Ostatnie 4 bajty można zastąpić dowolnym z poniższych:

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

Szybki , 101 bajtów

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

Wyjaśnienie

Pełny program. Wykorzystuje to dość dziwną sztuczkę: arc4random()jest członkiem Darwinmodułu, ale UIKittakże ma zainstalowaną tę funkcję, więc oszczędza bajt :) Używa także jednej z moich wskazówek golfowych Swift do powtarzania ciągów dowolną liczbę razy.

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 bajtów

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

R, 54 53 bajty

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

Podobny pomysł jak powyżej , ale ze skróconym sprintfkodem i literałem krótszego ciągu znaków. Zamiast \n(dwóch bajtów) używam dosłownego podziału linii (jeden bajt).

Try it online!

Rubinowy , 45 39 bajtów

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

Wypróbuj online!

Modyfikacja xpodczas pętli nie wpływa na licznik pętli. Wybrałem S jako szczególnie snakelową postać wyjściową.

-6 bajtów: użyj rand(3)-1zamiast [-1,0,1].sample. Dzięki, Eric Duminil !

SenseTalk , 237 198 bajtów

Jest to język, który poznałem i pokochałem około dziesięć lat temu. Jest to język skryptowy, który napędza narzędzie do automatycznego testowania Eggplant Functional . Przez wiele lat byłem zapalonym użytkownikiem tego narzędzia, zanim na jakiś czas dołączyłem do firmy. Nie jest to język, który najlepiej nadaje się do gry w golfa, ale pisanie go jest dla mnie bardzo przyjemne. Gra w golfa jest w rzeczywistości dość trudna, ponieważ język ma być gadatliwy i podobny do angielskiego ... zajęło mi sporo czasu do 237 bajtów.

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

Niegolfowane / Wyjaśnienie

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

Edycja: Zapisano 36 bajtów dzięki @mustachemoses

J , 23 bajty

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

Wypróbuj online!

PowerShell , 42 bajty

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

Wypróbuj online!

Pętle od 1do $l=30. Każdej iteracji umieszczamy $lspacje oraz xznak w potoku jako ciąg znaków, a następnie +=albo na -1, 0, 1podstawie Get-Randomdo $ldla następnej pętli. Te ciągi znaków są zbierane z potoku, a domniemany Write-Outputdaje nam listę oddzieloną znakiem nowej linii za darmo.

Bash, 53

• 3 bajty zapisane dzięki @Dennis

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

Wypróbuj online .

Galaretka , 18 bajtów

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

Wypróbuj online!

Wybrana postać to 0 . Jeśli dozwolone jest zwracanie listy znaków, Ymożna ją usunąć, a przesłanie można przekształcić w łańcuch niladyczny na 17 bajtów . Alternatywa .

Jak to działa

30Ç'С⁶ẋ; 0 EUR | Główny link Niladic.
30 | Począwszy od 30 ...
  Ç'С | ... Powtórz link pomocnika 29 razy i zbierz wyniki na liście.
             | (Ta lista zawiera pierwsze 30, więc w rzeczywistości jest 30 liczb).
      ⁶ẋ | Powtórz spację wiele razy dla każdego elementu na liście.
        ; 0 EUR | Dodaj 0 do każdego.
           Y | I dołącz przez nowe linie.
------------- +
1ŒRX + | Monadic link pomocnika. Alternatywnie możesz użyć µ1ŒRX + µ zamiast Ç.
1 | Dosłowny.
 ŒR | Zakres symetryczny od –1 do 1.
   X + | Wybierz tam losową liczbę i dodaj ją do argumentu.

Galaretka , 16 bajtów

Łącząc moje, rozwiązania Erika i Jonathana, możemy zagrać w golfa do 16 bajtów. Wybrana postać to 1 .

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

Wypróbuj online!

Podziękowania dla Jonathana Allana za heads-up (on Ṭ€o⁶).

Oktawa , 53 51 50 49 bajtów

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

Wypróbuj online!

Zapisano 1 bajt, nie wykonując już pętli. Zapisane innego jak Octave ma printfjak fprintf.

Ten nowy kod tworzy tablicę 30 losowych liczb całkowitych w zakresie -1:1. Następnie sumuje sumę macierzy i dodaje 30, co daje pożądaną sekwencję.

Wynik jest drukowany przy użyciu fprintfformatu, który brzmi: „Liczba dziesiętna, dopełniona do określonej szerokości, a następnie nowy wiersz. Szerokość będzie pierwszą wartością wejściową, a liczba dziesiętna drugą wartością. Jeśli liczba wartości wejściowych jest więcej, Octave będzie automatycznie powtarzał wydruk, aby uzyskać pożądany wynik.

Aby więc uzyskać pętlę, potrzebujemy tylko zerować zera między tablicą sekwencji, więc fprintffunkcja wykorzystuje każdą wartość w sekwencji jako szerokość, a każde zero jako cyfrę do wydrukowania.

Drukuje dane wyjściowe, takie jak:

                              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

Powyższy kod nie zawsze drukuje dokładnie 30 spacji w pierwszym wierszu. Będzie to 29, 30 lub 31. Aby to naprawić, użyj tej 53-bajtowej wersji:

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

Lua 81 75 bajtów

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

W for i=1,n ...tym to_exp n oceniana jest tylko raz przed wejściem do pętli, oszczędzając jeden bajt.

-6 dzięki @ user202729

Wypróbuj online!

Python 3.6 , 84 73 69 bajtów

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

Dzięki @WheatWizard za -11 bajtów. Dzięki @JoKing za -4 bajty.

ES5, 97 95 81 bajtów

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

ES5, 11298 bajtów, jeśli wymagany jest format funkcji:

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

Czerwony , 54 bajty

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

Wypróbuj online!