因此，我给自己写了一条单线纸，在控制台上打印了一条蛇。有点有趣，我想知道如何压缩我的代码...

这是一个（简短的）示例输出：

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

规格如下：

• 在每行中，一个非空白字符（随您喜欢）将被打印到控制台，最初在其左侧填充29至31个空格。
• 每次迭代，都会在这三个动作之间做出随机决定
  • 填充量减少1
  • 填充量保持不变
  • 填充量增加1

这样做30次，以在控制台上打印一条30段长的蛇。

以字节为单位的最短答案将获胜。

05AB1E，15 14字节

30DF2Ý<+ΩD0sú,

在线尝试！

用途0。

说明

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

随机Brainfuck，123个122 121字节

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

在线尝试！

随机Brainfuck是Brainfuck的扩展，增加了?命令的有用功能，该命令将当前单元格设置为随机字节。这打印出一条蛇! s，看起来比蛇更有趣的是脚步声。

怎么运行的：

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

另一种解决方案是刺到信的问题，而不是精神。

87字节

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

在线尝试！

强烈偏向于不使用填充，但是增加或减少填充都同样可能。每个人发生的机会少于256分之一。

C（gcc），61 58 56字节

编辑答案以反映规则更改...

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

在线尝试！

视网膜，24字节

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

在线尝试！

说明

30* +

将工作字符串初始化为第一行，即30个空格和一个+。

-29{¶<`^
 

第二行上有一个空格。-29{将程序的其余部分包装在一个循环中，该循环将运行29次。¶<在每个循环迭代的开始以末尾的换行符打印工作字符串。原子级本身在字符串的开头插入一个空格（基本思想是先插入一个空格，然后随机删除0–2个空格，因为这比在删除，插入和无操作之间随机选择要短一个字节）。

S,2@1`

这使空的正则表达式与输入匹配，从而为我们提供了字符之间（以及字符串的开头和结尾）之间的每个位置。然后,2仅保留前三个匹配项，即零个，一个和两个空格后的匹配项。@从这三个匹配中选择一个随机。然后，分割阶段（S）在该匹配项附近分割输入。并且1告诉它仅保留拆分的第二部分。换句话说，我们将丢弃所有随机匹配的内容。

最终循环迭代的结果，第30行隐式打印在程序的末尾。

VBA，60 59 49字节

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

将其粘贴到“立即”窗口中，然后按Enter。（确保已关闭显式声明！）

远更有可能比留在移动线（即动作不相同的权重），但不是规定的要求（幸运的！）

{编辑} 通过之间去除空间保存1个字节=1和To

{EDIT2} 由于remoel的评论节省了10个字节

旧版本：

'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核心），112 110 106 100 99 98个字节

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

-1个字节感谢@raznagul。
-1个字节感谢@auhmaan。

说明：

在线尝试。

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个字节

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

在线尝试！

说明：

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个字节

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

取决于f “返回”在函数中分配给n的值，这是未定义的行为，但是在未启用优化的情况下与gcc一致。

在线尝试！

JavaScript（ES8），63 62 60字节

包括结尾的换行符。*2-1可以用-.5节省1个字节的方式替换，但是每行与前一行相同长度的机会将大大增加。当然，由于挑战中未定义“随机”，因此可以用new Date%3-1总字节数55代替RNG 。

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

多亏了有人删除了我的评论，才节省了一个字节。我实际上已经用这种方法尝试过了repeat，padStart但是没有想到尝试padEnd-不知道为什么！

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

<pre id=o>

奖金

对于相同数量的字节，这是一个以起始空格和迭代次数为输入的版本。

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字节

第一次打高尔夫球，我敢肯定会更好。

编辑：修复了第一行，感谢Steadybox。

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

在线尝试！

 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字节

简单的方法：

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

在线尝试！

感谢@Rod节省了一些字节！感谢@ovs -1字节！

编辑：更改变量名称并将输出字符串更改为字母“ s”

88字节的更多类似蛇的输出：

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

APL（Dyalog），20字节

多亏了ngn，节省了1个字节

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

在线尝试！

木炭，14字节

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

在线尝试！链接是详细版本的代码。说明：

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

如果没有初始缩进要求，则只有10个字节。

PHP，61字节

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

在线尝试！

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

Explanation:

Try it 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

Old 119 byte answer:

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

Explanation:

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

Thanks to Zahiro Mor for 2 extra bytes!

Try it online!

Japt, 13 bytes

Returns an array of lines.

30ÆQù1nH±1n3ö

Test it

Explanation

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

For 2 bytes less, here's a version that takes the number of starting spaces & iterations as input.

U°ÆQùU±1n3ö

Try it

Alternative RNGs

The last 4 bytes can be replaced with any of the following:

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}

Explanation

A full program. This uses a rather odd trick: arc4random() is a member of the Darwin module, but UIKit also comes with this function installed, so it saves a byte :) Also uses one of my Swift golfing tips for repeating strings an arbitrary number of times.

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

Similar idea as above, but with shortened sprintf code and a shorter character string literal. Instead of \n (two bytes) I’m using a literal line break (one byte).

Try it online!

Ruby, 45 39 bytes

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

Try it online!

Modifying x during the loop does not affect the loop counter. I chose S as a particularly snakelike output character.

-6 bytes: Use rand(3)-1 instead of [-1,0,1].sample. Thanks, Eric Duminil!

SenseTalk, 237 198 Bytes

This is a language that I came to know and love about a decade ago. It's the scripting language that drives the automated testing tool Eggplant Functional. I was an avid user of the tool for many years before joining the company for a while. It's not the most golf-capable language, but I find it very enjoyable to write in. Golfing in it is actually quite challenging as the language is meant to be verbose and English-like... took me quite a while to get it down to 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/Explanation

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: Saved 36 bytes thanks to @mustachemoses

J, 23 bytes

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

Try it online!

PowerShell, 42 bytes

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

Try it online!

Loops from 1 to $l=30. Each iteration we put $l spaces plus an x onto the pipeline as a string, then += either of -1, 0, 1 based on Get-Random into $l for the next loop. Those strings are gathered from the pipeline and an implicit Write-Output gives us a newline-separated list for free.

Bash, 53

• 3 bytes saved thanks to @Dennis

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

Try it online.

Jelly, 18 bytes

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

Try it online!

The chosen character is 0. If returning a list of list of characters is allowed, then the Y can be dropped and the submission can be turned into a niladic chain for 17 bytes. Alternative.

How it works

30ǒС⁶ẋ;€0Y | Niladic main link.
30           | Starting from 30...
  ǒС       | ... Repeat the helper link 29 times and collect the results in a list.
             | (This list includes the first 30, so there are actually 30 numbers).
      ⁶ẋ     | Repeat a space that many times, for each item in the list.
        ;€0  | Append a 0 to each.
           Y | And join by newlines.
-------------+
1ŒRX+        | Monadic helper link. Alternatively, you can use µ1ŒRX+µ instead of the Ç.
1            | The literal one.
 ŒR          | Symmetric range from –1 to 1.
   X+        | Choose a random number therein and add it to the argument.

Jelly, 16 bytes

Combining mine, Erik’s and Jonathan’s solutions, we can golf this down to 16 bytes. The chosen character is 1.

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

Try it online!

Thanks to Jonathan Allan for the heads-up (on Ṭ€o⁶).

Octave, 53 51 50 49 bytes

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

Try it online!

Saved 1 byte by no longer doing any looping. Saved another as Octave has printf as well as fprintf.

This new code creates an array of 30 random integers in the range -1:1. It then cumulatively sums the array and adds 30, which gives the desired sequence.

The result is printed using fprintf with a format that says "A decimal number, padded to a specified width, followed by a new line. The width will be the first value input, and the decimal number will be the second value input. If the number of values input is more than this, Octave will keep repeating the print automatically to get the desired output.

To achieve the looping then, we need only interleave zeros between the sequence array so the fprintf function uses each value in the sequence as a width, and each zero as the digit to be printed.

Prints an output like:

                              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

The above code doesn't always print exactly 30 spaces on the first line. It will be either 29, 30, or 31. To correct that, you would use this 53 byte version:

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 ... the to_exp n is evaluated only once before entering the loop, saving one byte.

-6 thanks to @user202729

Try it online!

Python 3.6, 84 73 69 bytes

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

Thanks to @WheatWizard for -11 bytes. Thanks to @JoKing for -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, 112 98 bytes if function format is needed:

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

Red, 54 bytes

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

Try it online!