Vì vậy, tôi đã viết cho mình một tấm lót có in hình con rắn trên bàn điều khiển. Đó là một niềm vui và tôi tự hỏi làm thế nào tôi có thể ngưng tụ mã của mình ...

Đây là một ví dụ đầu ra (ngắn):

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

Đây là thông số kỹ thuật:

• Trong mỗi dòng, một ký tự không phải khoảng trắng (tùy theo ý thích của bạn) được in ra bàn điều khiển, ban đầu có 29 đến 31 khoảng trắng ở bên trái của nó.
• Mỗi lần lặp lại, một quyết định ngẫu nhiên được đưa ra giữa ba hành động này
  • Số lượng đệm giảm đi 1
  • Số lượng đệm vẫn giữ nguyên
  • Số lượng đệm tăng thêm 1

Làm điều này 30 lần, để in một con rắn dài 30 đoạn lên bàn điều khiển.

Câu trả lời ngắn nhất trong byte thắng.

05AB1E , 15 14 byte

30DF2Ý<+ΩD0sú,

Hãy thử trực tuyến!

Công dụng 0.

Giải trình

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 ngẫu nhiên , 123 122 121 byte

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

Hãy thử trực tuyến!

Random Brainfuck là một phần mở rộng của brainfuck, với sự bổ sung hữu ích của ?lệnh, đặt ô hiện tại thành một byte ngẫu nhiên. Điều này in một con rắn làm bằng !s, trông giống như bước chân hơn là một con rắn đủ vui.

Làm thế nào nó hoạt động:

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

Một giải pháp khác dính vào thư của câu hỏi, hơn là tinh thần.

87 byte

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

Hãy thử trực tuyến!

Điều này rất thiên về việc để lại phần đệm một mình, nhưng tăng hoặc giảm phần đệm đều có thể như nhau. Mỗi người có ít hơn 1 trên 256 cơ hội xảy ra.

C (gcc) , 61 58 56 byte

Trả lời chỉnh sửa để phản ánh các thay đổi quy tắc ...

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

Hãy thử trực tuyến!

Võng mạc , 24 byte

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

Hãy thử trực tuyến!

Giải trình

30* +

Khởi tạo chuỗi làm việc đến dòng đầu tiên, tức là 30 khoảng trắng và a +.

-29{¶<`^
 

Có một khoảng trống trên dòng thứ hai. -29{kết thúc phần còn lại của chương trình trong một vòng lặp, được chạy 29 lần. ¶<in chuỗi làm việc ở đầu mỗi vòng lặp với một dòng cấp dữ liệu. Chính giai đoạn nguyên tử chèn một khoảng trắng ở đầu chuỗi (ý tưởng cơ bản là chèn một khoảng trắng, sau đó xóa ngẫu nhiên 0 không gian 2, bởi vì đó là một byte ngắn hơn so với việc chọn ngẫu nhiên giữa xóa, chèn và không op).

S,2@1`

Điều này khớp với regex trống so với đầu vào, cung cấp cho chúng ta mọi vị trí giữa các ký tự (và bắt đầu và kết thúc chuỗi). Sau đó ,2chỉ giữ lại ba trận đấu đầu tiên, tức là các trận đấu sau 0, một và hai khoảng trắng. @chọn ngẫu nhiên một trong ba trận đấu đó Sau đó, giai đoạn phân chia ( S) phân tách đầu vào xung quanh trận đấu đó. Và1 bảo nó chỉ giữ lại phần thứ hai của sự phân chia. Nói cách khác, chúng tôi loại bỏ mọi thứ cho đến trận đấu ngẫu nhiên của chúng tôi.

Dòng thứ 30, là kết quả của lần lặp vòng lặp cuối cùng, được in ngầm ở cuối chương trình.

VBA, 60 59 49 Bytes

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

Dán nó trong cửa sổ Ngay lập tức và nhấn enter. (Đảm bảo tắt khai báo rõ ràng!)

Có khả năng di chuyển nhiều hơn là ở trong một dòng (nghĩa là các hành động không có trọng số như nhau) nhưng đó không phải là một yêu cầu cụ thể (May mắn thay!)

{EDIT} đã lưu 1 byte bằng cách xóa khoảng trắng giữa =1vàTo

{EDIT2} Đã lưu 10 byte nhờ nhận xét của remoel

Phiên bản cũ:

'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 nhờ @raznagul .
-1 byte nhờ @auhmaan .

Giải trình:

Hãy thử trực tuyến.

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 byte

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

Hãy thử trực tuyến!

Giải trình:

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 byte

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

Phụ thuộc vào f "trả lại" giá trị được gán cho n trong hàm, đây là hành vi không xác định, nhưng hoạt động ổn định với gcc khi không bật tối ưu hóa.

Hãy thử trực tuyến!

JavaScript (ES8), 63 62 60 byte

Bao gồm một dòng mới. *2-1có thể được thay thế bằng -.5để tiết kiệm 1 byte nhưng cơ hội của mỗi dòng có cùng độ dài với dòng trước đó sẽ được tăng lên rất nhiều. Tất nhiên, vì "ngẫu nhiên" không được xác định trong thử thách, RNG có thể được thay thế bằng new Date%3-1tổng số byte là 55 .

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

Đã lưu một byte nhờ một người đã xóa bình luận của họ trước khi tôi có thể bắt được tên. Tôi thực sự đã thử nó theo cách này repeatvà padStartnhưng không nghĩ sẽ thửpadEnd - không biết tại sao!

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

<pre id=o>

Tiền thưởng

Với cùng số byte, đây là phiên bản lấy số lượng không gian bắt đầu & lặp lại làm đầu và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 byte

Golf đầu tiên, tôi chắc chắn rằng nó có thể tốt hơn nhiều ..

Chỉnh sửa: Đã sửa lỗi dòng đầu tiên nhờ Steadybox .

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

Hãy thử trực tuyến!

 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 byte

Cách tiếp cận đơn giản:

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

Hãy thử trực tuyến!

Cảm ơn @Rod vì đã lưu một số byte! Cảm ơn @ovs cho -1 byte!

Chỉnh sửa: đã thay đổi tên biến và chuỗi đầu ra thành chữ 's'

Đầu ra giống rắn hơn cho 88 byte:

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

APL (Dyalog) , 20 byte

Lưu 1 byte nhờ ngn

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

Hãy thử trực tuyến!

Than , 14 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

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

Sẽ chỉ có 10 byte nếu không có yêu cầu thụt đầu tiên.

PHP, 61 byte

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

Hãy thử trực tuyến!

Java 8, 131 129 127 126 119 108 101 byte

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

Giải trình:

Hãy thử trực tuyến.

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

Câu trả lời cũ 119 byte:

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

Giải trình:

Hãy thử trực tuyến.

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 byte

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

Cảm ơn Zahiro Mor vì đã có thêm 2 byte!

Hãy thử trực tuyến!

Japt , 13 byte

Trả về một mảng các dòng.

30ÆQù1nH±1n3ö

Kiểm tra nó

Giải trình

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

Tiền thưởng

Đối với 2 byte ít hơn , đây là phiên bản lấy số lượng không gian bắt đầu & lặp lại làm đầu vào.

U°ÆQùU±1n3ö

Thử nó

RNG thay thế

4 byte cuối cùng có thể được thay thế bằng bất kỳ điều nào sau đây:

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!