Also schrieb ich mir einen Einzeiler, der eine Schlange auf die Konsole druckte. Es macht ein bisschen Spaß und ich fragte mich, wie ich meinen Code komprimieren könnte ...

Hier ist eine (kurze) Beispielausgabe:

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

Hier sind die Spezifikationen:

• In jeder Zeile wird ein einzelnes Nicht-Whitespace-Zeichen (je nachdem, was Sie möchten) auf die Konsole gedruckt, wobei anfangs 29 bis 31 Leerzeichen links daneben stehen.
• Bei jeder Iteration wird eine zufällige Entscheidung zwischen diesen drei Aktionen getroffen
  • Der Umfang der Polsterung verringert sich um 1
  • Der Umfang der Polsterung bleibt gleich
  • Die Menge der Polsterung erhöht sich um 1

Tun Sie dies 30 Mal, um eine 30-Segment lange Schlange auf die Konsole zu drucken.

Die kürzeste Antwort in Bytes gewinnt.

05AB1E , 15 14 Bytes

30DF2Ý<+ΩD0sú,

Probieren Sie es online!

Verwendet 0.

Erläuterung

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

Zufälliges Brainfuck , 123 122 121 Bytes

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

Probieren Sie es online!

Random Brainfuck ist eine Erweiterung von Brainfuck mit dem hilfreichen Zusatz des ?Befehls, der die aktuelle Zelle auf ein zufälliges Byte setzt. Dies druckt eine Schlange aus !s, die eher wie Schritte als lustig genug wie eine Schlange aussieht.

Wie es funktioniert:

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

Eine andere Lösung, die eher am Buchstaben der Frage als am Geist festhält.

87 Bytes

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

Probieren Sie es online!

Dieser ist stark vorgespannt, um die Polsterung in Ruhe zu lassen, aber eine Vergrößerung oder Verkleinerung der Polsterung ist beide gleichermaßen möglich. Jedes hat eine etwas geringere Chance als 1 zu 256.

C (GCC) , 61 58 56 Byte

Antwort bearbeitet, um Änderungen der Regeln widerzuspiegeln ...

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

Probieren Sie es online!

Retina , 24 Bytes

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

Probieren Sie es online!

Erläuterung

30* +

Initialisieren Sie den Arbeitsstring in der ersten Zeile, dh 30 Leerzeichen und a +.

-29{¶<`^
 

In der zweiten Zeile ist ein Leerzeichen. -29{Wickelt den Rest des Programms in eine Schleife, die 29-mal ausgeführt wird. ¶<druckt den Arbeitsstring am Anfang jeder Schleifeniteration mit einem nachfolgenden Zeilenvorschub. Die atomare Stufe selbst fügt ein Leerzeichen am Anfang des Strings ein (die Grundidee ist, ein Leerzeichen einzufügen und dann zufällig 0–2 Leerzeichen zu entfernen, da dies ein Byte kürzer ist als die zufällige Auswahl zwischen Löschen, Einfügen und No-Op).

S,2@1`

Dies vergleicht den leeren regulären Ausdruck mit der Eingabe, die uns jede Position zwischen Zeichen (sowie Anfang und Ende der Zeichenfolge) gibt. Dann ,2bleiben nur die ersten drei Übereinstimmungen erhalten, dh die Übereinstimmungen nach null, eins und zwei Leerzeichen. @wählt zufällig eine dieser drei Übereinstimmungen aus. Dann Steilt die Aufteilungsstufe ( ) die Eingabe um diese Übereinstimmung auf. Und das 1sagt ihm, er solle nur den zweiten Teil der Teilung behalten. Mit anderen Worten, wir verwerfen alles bis zu unserer zufälligen Übereinstimmung.

Die 30. Zeile, die das Ergebnis der letzten Schleifeniteration ist, wird implizit am Ende des Programms ausgegeben.

VBA, 60 59 49 Bytes

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

Fügen Sie es in das Direktfenster ein und drücken Sie die Eingabetaste. (Stellen Sie sicher, dass die explizite Deklaration deaktiviert ist!)

Es ist weitaus wahrscheinlicher, sich zu bewegen, als in einer Linie zu bleiben (dh Aktionen sind nicht gleich gewichtet), aber das war keine bestimmte Voraussetzung (Zum Glück!)

{EDIT} 1 Byte durch Entfernen des Leerzeichens zwischen =1und gespeichertTo

{EDIT2} Gespeichert 10 Bytes dank remoel Kommentar

Alte Versionen:

'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 Byte

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 dank @raznagul .
-1 Byte dank @auhmaan .

Erläuterung:

Probieren Sie es online aus.

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

Probieren Sie es online!

Erläuterung:

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

Hängt davon ab, dass f den Wert "zurückgibt", der n in der Funktion zugewiesen wurde. Dies ist ein undefiniertes Verhalten, das jedoch mit gcc konsistent funktioniert, wenn keine Optimierungen aktiviert sind.

Probieren Sie es online!

JavaScript (ES8), 63 62 60 Bytes

Beinhaltet einen nachgestellten Zeilenumbruch. *2-1könnte durch -.5eine Einsparung von 1 Byte ersetzt werden, aber die Wahrscheinlichkeit, dass jede Zeile dieselbe Länge wie die vorherige Zeile hat, würde sich erheblich erhöhen. Natürlich wird als „zufällig“ nicht in der Herausforderung definiert, die RNG könnte ersetzt werden new Date%3-1für eine Anzahl von insgesamt Byte 55 .

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

Dank an jemanden, der seinen Kommentar gelöscht hat, bevor ich den Namen finden konnte, wurde ein Byte gespeichert. Ich hatte es tatsächlich auf diese Weise versucht repeatund padStartdachte nicht daran, es zu versuchen padEnd- ich weiß nicht warum!

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

<pre id=o>

Bonus

Für die gleiche Anzahl von Bytes ist hier eine Version, die die Anzahl der Start-Leerzeichen und Iterationen als Eingabe verwendet.

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

Erste Golf, ich bin sicher, es könnte viel besser sein ..

Bearbeiten: Erste Zeile dank Steadybox korrigiert .

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

Probieren Sie es 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

Einfacher Ansatz:

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

Probieren Sie es online!

Vielen Dank an @Rod für das Speichern einiger Bytes! Vielen Dank an @ovs für -1 Byte!

Bearbeiten: Variablenname und Ausgabezeichenfolge auf den Buchstaben 's' geändert

Mehr schlangenartige Ausgabe für 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 gespart dank ngn

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

Probieren Sie es online!

Holzkohle , 14 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

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

Wäre nur 10 Bytes, wenn es keine anfängliche Einrückungsanforderung gäbe.

PHP, 61 Bytes

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

Probieren Sie es 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;}

Erläuterung:

Probieren Sie es online aus.

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

Alte 119-Byte-Antwort:

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

Erläuterung:

Probieren Sie es online aus.

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

Vielen Dank an Zahiro Mor für 2 zusätzliche Bytes!

Probieren Sie es online!

Japt , 13 Bytes

Gibt ein Array von Zeilen zurück.

30ÆQù1nH±1n3ö

Probier es aus

Erläuterung

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

Bonus

Für 2 Bytes weniger ist hier eine Version, die die Anzahl der Start-Leerzeichen und Iterationen als Eingabe verwendet.

U°ÆQùU±1n3ö

Versuch es

Alternative RNGs

Die letzten 4 Bytes können durch eines der folgenden ersetzt werden:

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

Schnell , 101 Bytes

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

Erläuterung

Ein volles Programm. Dies verwendet einen ziemlich seltsamen Trick: arc4random()Ist ein Mitglied des DarwinModuls, hat aber UIKitauch diese Funktion installiert, so dass es ein Byte speichert :) Verwendet auch einen meiner Swift-Golftipps, um Saiten beliebig oft zu wiederholen.

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

Ähnliche Idee wie oben , jedoch mit verkürztem sprintfCode und einem kürzeren Zeichenkettenliteral. Anstelle von \n(zwei Bytes) verwende ich einen wörtlichen Zeilenumbruch (ein Byte).

Try it online!

Ruby , 45 39 Bytes

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

Probieren Sie es online!

Änderungen xwährend der Schleife wirken sich nicht auf den Schleifenzähler aus. Ich habe S als besonders schlangenartiges Ausgabezeichen gewählt.

-6 Bytes: Verwenden Sie rand(3)-1anstelle von [-1,0,1].sample. Danke, Eric Duminil !

SenseTalk , 237 198 Bytes

Dies ist eine Sprache, die ich vor etwa einem Jahrzehnt kennen und lieben gelernt habe. Es ist die Skriptsprache, die das automatisierte Test-Tool Eggplant Functional steuert . Ich war viele Jahre lang begeisterter Benutzer des Tools, bevor ich eine Weile in das Unternehmen eintrat. Es ist nicht die Golf-fähigste Sprache, aber ich finde es sehr unterhaltsam, darin zu schreiben. Das Golfen ist eigentlich eine ziemliche Herausforderung, da die Sprache wortreich und englischartig sein soll bis 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 / Erklärung

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

Bearbeiten: 36 Bytes dank @mustachemoses gespeichert

J , 23 Bytes

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

Probieren Sie es online!

PowerShell , 42 Byte

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

Probieren Sie es online!

Schleifen von 1bis $l=30. Bei jeder Iteration werden $lLeerzeichen plus ein xals Zeichenfolge in die Pipeline eingefügt, und dann wird für die nächste Schleife +=entweder -1, 0, 1auf Get-Randomin basiert $l. Diese Zeichenfolgen werden aus der Pipeline gesammelt, und ein Implizit Write-Outputgibt uns kostenlos eine durch Zeilenumbrüche getrennte Liste.

Bash, 53

• 3 Bytes gespart dank @Dennis

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

Probieren Sie es online aus .

Jelly , 18 Bytes

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

Probieren Sie es online!

Das gewählte Zeichen ist 0 . Wenn das Zurückgeben einer Liste mit Zeichen zulässig ist, Ykann das gelöscht und die Übermittlung für 17 Byte in eine Niladenkette umgewandelt werden . Alternative .

Wie es funktioniert

30 € 0Y | Niladic Hauptverbindung.
30 | Ab 30 ...
  Ç'С | ... Wiederholen Sie den Hilfslink 29 Mal und sammeln Sie die Ergebnisse in einer Liste.
             | (Diese Liste enthält die ersten 30, es gibt also tatsächlich 30 Zahlen).
      ⁶ẋ | Wiederholen Sie ein Leerzeichen so oft für jedes Element in der Liste.
        € 0 | Fügen Sie jeweils eine 0 hinzu.
           Y | Und mach mit bei Newlines.
------------- +
1ŒRX + | Monadischer Helferlink. Alternativ können Sie µ1ŒRX + µ anstelle von Ç verwenden.
1 | Der buchstäbliche.
 ŒR | Symmetrischer Bereich von –1 bis 1.
   X + | Wählen Sie eine Zufallszahl aus und fügen Sie sie dem Argument hinzu.

Gelee , 16 Bytes

Wenn wir die Lösungen von Erik und Jonathan kombinieren, können wir das auf 16 Bytes reduzieren. Das gewählte Zeichen ist 1 .

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

Probieren Sie es online!

Vielen Dank an Jonathan Allan für das Heads-up Ṭ€o⁶.

Oktave , 53 51 50 49 Bytes

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

Probieren Sie es online!

1 Byte gespart, indem keine Schleife mehr ausgeführt wird. Ein anderer wurde gespeichert, wie es Octave printfauch getan hat fprintf.

Dieser neue Code erstellt ein Array mit 30 zufälligen Ganzzahlen im Bereich -1:1. Es summiert dann das Array kumulativ und addiert 30, was die gewünschte Sequenz ergibt.

Das Ergebnis wird fprintfim Format "Eine Dezimalzahl, die auf eine bestimmte Breite aufgefüllt wird, gefolgt von einer neuen Zeile" gedruckt . Die Breite wird als erster Wert und die Dezimalzahl als zweiter Wert eingegeben Wenn mehr Werte eingegeben werden, wiederholt Octave den Druck automatisch, um die gewünschte Ausgabe zu erhalten.

Um die Schleifenbildung dann zu erreichen, müssen wir nur Nullen zwischen dem Sequenzarray verschachteln, sodass die fprintfFunktion jeden Wert in der Sequenz als Breite und jede Null als zu druckende Ziffer verwendet.

Druckt eine Ausgabe wie:

                              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

Der obige Code gibt nicht immer genau 30 Leerzeichen in der ersten Zeile aus. Es wird entweder 29, 30 oder 31 sein. Um dies zu korrigieren, würden Sie diese 53-Byte-Version verwenden:

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

In for i=1,n ...der to_exp n wird nur einmal vor dem Eintritt in die Schleife ausgewertet, wobei ein Byte gespeichert wird.

-6 danke an @ user202729

Probieren Sie es online!

Python 3.6 , 84 73 69 Bytes

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

Danke an @WheatWizard für -11 Bytes. Vielen Dank an @JoKing für -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, wenn das Funktionsformat benötigt wird:

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

Rot , 54 Bytes

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

Probieren Sie es online!