Bạn không biết gì Những điều tôi làm cho " Chaos là một cái thang " là một dòng đáng nhớ từ loạt phim truyền hình Game of Thrones .

Mục đích của thử thách này là xây dựng một nấc thang từ sự hỗn loạn, trong nghệ thuật ASCII.

Các thách thức

Đầu vào

• Chiều rộng thang, W >= 3(số nguyên)
• Bước cao, H >= 2(số nguyên)
• Số bậc thang, N >= 2(số nguyên).

Đầu ra

Một cái thang có các nấc ngang và đường ray dọc , rộng tất cả 1 ký tự. Chiều rộng thang ( W) bao gồm hai đường ray và chiều cao bước ( H) bao gồm các bậc thang tương ứng.

Tất cả các nấc thang, bao gồm cả trên cùng và dưới cùng, sẽ có một đoạn đường ray dọc có chiều dài H-1trực tiếp bên trên và bên dưới. Ví dụ sẽ làm cho điều này rõ ràng hơn.

Thang sẽ được tạo từ các ký tự ASCII có thể in, không có khoảng trắng , nghĩa là phạm vi bao gồm từ !(điểm mã 33) đến ~(điểm mã 126). Các ký tự thực tế sẽ được chọn ngẫu nhiên . Với các đầu vào, mỗi lựa chọn ngẫu nhiên của các ký tự phải có xác suất khác không. Ngoài ra, phân phối xác suất là tùy ý.

Khoảng trắng hàng đầu hoặc dấu , theo chiều ngang hoặc dọc, được cho phép.

Thí dụ

Cho W=5, H=3, N=2, một đầu ra có thể là như sau.

x   :
g   h
q$UO{
t   T
6   <
bUZXP
8   T
5   g

Lưu ý rằng tổng chiều cao là H*(N+1)-1, vì có các Nbậc và N+1phần dọc.

Quy tắc bổ trợ

• Phương tiện và định dạng đầu vào là linh hoạt như bình thường. Ví dụ: bạn có thể nhập ba số theo bất kỳ thứ tự nào hoặc một mảng chứa chúng.

• Đầu ra có thể thông qua STDOUT hoặc một đối số được trả về bởi một hàm. Trong trường hợp này, nó có thể là một chuỗi có dòng mới, mảng ký tự 2D hoặc một chuỗi các chuỗi.

• Một chương trình hoặc một chức năng có thể được cung cấp.

• Sơ hở tiêu chuẩn bị cấm.

• Mã ngắn nhất trong byte thắng.

Các trường hợp thử nghiệm

Đối với mỗi W, H, Nđầu ra có thể được hiển thị.

W=5, H=3, N=2:

\   ~
:   K
ke:[E
5   u
0   _
8Fr.D
#   r
7   X


W=3, H=2, N=2:

$ X
Mb)
0 ]
(T}
j 9


W=12, H=4, N=5:

d          Y
P          `
5          3
p$t$Ow7~kcNX
D          x
`          O
*          H
LB|QX1'.[:[F
p          p
x          (
2          ^
ic%KL^z:KI"^
C          p
(          7
7          h
TSj^E!tI&TN8
|          [
<          >
=          Q
ffl`^,tBHk?~
O          +
p          e
n          j


W=20, H=5, N=3:

G                  %
o                  y
%                  3
-                  7
U'F?Vml&rVch7{).fLDF
o                  }
U                  I
h                  y
a                  g
;W.58bl'.iHm\8v?bIn&
,                  U
N                  S
4                  c
5                  r
F3(R|<BP}C'$=}xK$F]^
'                  h
h                  u
x                  $
6                  5    

Thạch ,  24 23  22 byte

«þỊoU$ẋ⁵‘¤Ḋ×94X€€+32ỌY

Một chương trình đầy đủ lấy ba đối số W, H, Nvà in kết quả.

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

Làm sao?

Xây dựng mặt nạ mảng 2d của một nấc đơn và các phần dọc của nó bên dưới, lặp lại N+1thời gian và loại bỏ các nấc trên cùng sau đó đặt các ký tự hoặc khoảng trắng ngẫu nhiên tùy thuộc vào giá trị mặt nạ.

«þỊoU$ẋ⁵‘¤Ḋ×94X€€+32ỌY - Main link: W, H (N is third input / 5th command line argument)
 þ                     - outer product (build a table using):
«                      -  minimum
                       -  ...note: þ implicitly builds ranges of W and H prior
  Ị                    - insignificant? (abs(z)<=1) - yields a W by H 2-d array,
                       -   all zeros except the left and top edges which are 1s
     $                 - last two links as a monad:
    U                  -   upend (reverse each row)
   o                   -   or (vectorises) - giving us our |‾| shape of 1s
         ¤             - nilad followed by link(s) as a nilad:
       ⁵               -   5th command line argument, N
        ‘              -   increment -> N+1
      ẋ                - repeat list - giving us our ladder-mask plus a top rung)
          Ḋ            - dequeue - remove the top rung
            94         - literal ninety-four
           ×           - multiply (vectorises) - replace the 1s with 94s
              X€€      - random for €ach for €ach - 0 -> 0; 94 -> random integer in [1,94]
                  32   - literal thirty-two
                 +     - add (vectorises) - 0 -> 32; random integers now from [33,126]
                    Ọ  - character from ordinal (vectorises)
                     Y - join with newlines
                       - implicit print

Hoạt động ngôn ngữ kịch bản Flashpoint , 643 624 byte

f={l=["""","!","#","$","%","&","'","(",")","*","+",",","-",".","/","0","1","2","3","4","5","6","7","8","9",":",";","<","=",">","?","@","A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z","[","\","]","^","_","`","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z","{","|","}","~"];t=_this;w=t select 0;r={l select random 92};v="";s=v;i=2;while{i<w}do{i=i+1;v=v+" "};p={i=1;while{i<t select 1}do{i=i+1;s=s+call r+v+call r+"\n"}};k=0;call p;while{k<t select 2}do{k=k+1;i=0;while{i<w}do{i=i+1;s=s+call r};s=s+"\n";call p};s}

Vô lý dài vì không có cách nào để tạo các ký tự từ mã ký tự.

Gọi với:

hint ([5, 3, 2] call f)

Đầu ra:

Các bậc thang là hỗn loạn thêm vì phông chữ không phải là đơn cách.

Chưa được kiểm soát:

f =
{
    l = ["""","!","#","$","%","&","'","(",")","*","+",",","-",".","/","0","1","2","3","4","5","6","7","8","9",":",";","<","=",">","?","@","A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z","[","\","]","^","_","`","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z","{","|","}","~"];

    t = _this;
    w = t select 0;

    r =
    {
        l select random 92
    };

    v = "";
    s = v;

    i = 2;
    while {i < w} do 
    {
        i = i + 1;
        v = v + " "
    };

    p =
    {
        i = 1;
        while {i < t select 1} do 
        {
            i = i + 1;
            s = s + call r + v + call r + "\n"
        }
    };

    k = 0;
    call p;
    while {k < t select 2} do 
    {
        k = k + 1;

        i = 0;
        while {i < w} do
        {
            i = i + 1;
            s = s + call r
        };
        s = s + "\n";

        call p
    };

    s
}

05AB1E , 29 byte

Đầu vào được thực hiện theo thứ tự N, H, W

>*GNUžQ¦©.RIÍFð®.R«X²Öè}®.RJ,

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

Giải trình

>*G                              # for N in [1 ... (N+1)*H)-1] do:
   NU                            # store N in variable X
     žQ                          # push a string of printable ascii
       ¦©                        # remove the first (space) and save a copy in register
         .R                      # pick a random character
           IÍF                   # W-2 times do:
              ð                  # push a space
               ®.R               # push a random ascii character
                  «              # concatenate
                   X²Ö           # push X % H == 0
                      è          # index into the string of <space><random_char> with this
                       }         # end inner loop
                        ®.R      # push a random ascii character
                           J,    # join everything to a string and print

C, 95 byte

f(w,h,n,i){++w;for(i=0;i++<w*~(h*~n);)putchar(i%w?~-i%w%(w-2)*((i/w+1)%h)?32:33+rand()%94:10);}

R , 138 129 111 98 93 byte

-13 byte nhờ Neal Fultz!

-1 byte nhờ Robin Ryder

function(W,H,N){m=matrix(intToUtf8(32+sample(94,W*(h=H*N+H-1),T),T),h)
m[-H*1:N,3:W-1]=" "
m}

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

Chức năng ẩn danh; trả về kết quả dưới dạng ma trận.

Nhờ câu hỏi Word Grids đó , tôi đã suy nghĩ về ma trận nhiều hơn bình thường. Tôi quan sát thấy các bậc thang nằm trong các hàng ma trận đó là bội số của chiều cao bước H(R là 1 chỉ mục) và các đường ray là cột đầu tiên và cuối cùng, 1và W. Vì vậy, tôi tạo một ma trận gồm các ký tự ASCII ngẫu nhiên và thay thế các chữ cái không khớp với các tiêu chí đó bằng dấu cách và trả về ma trận. Liên kết TIO in nó ra độc đáo.

Neal Fultz đã đề xuất một chỉ mục khác cho các ký tự khoảng trắng, [-H*(1:N),3:W-1]thay thế tất cả các ký tự ngoại trừ các ký tự trong các hàng bội số của H: -H*(1:N)và không phải trên cạnh, 3:W-1<==> 2:(W-1).

R , 121 byte

function(W,H,N)for(i in 1:(H*N+H-1)){for(j in 1:W)cat("if"(!(i%%H&j-1&j-W),sample(intToUtf8(33:126,T),1)," "))
cat("\n")}

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

Một cải tiến so với cách tiếp cận dựa trên ma trận ban đầu mà tôi đã bắt đầu; đó là cùng một thuật toán nhưng forcác vòng lặp ngắn hơn so với việc xây dựng và in một ma trận (nhưng không phải là nếu tôi không in nó!)

Perl 5 , 81 byte

Mã 80 byte + 1 cho -p.

/ \d+ /;$_=(($}=(_.$"x($`-2)._.$/)x($&-1))._ x$`.$/)x$'.$};s/_/chr 33+rand 94/ge

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

Than , 34 32 byte

Ｅ…¹×⁺¹ＮＮ⪫ＥＩζ⎇∧﹪ιＩη﹪λ⁻Ｉζ¹ §⮌γ‽⁹⁴ω

Hãy thử trực tuyến!Lấy đầu vào theo thứ tự xấp xỉ N, H, W. Verbose ( Plus(InputNumber(), 1)hiện đang bị hỏng trên TIO). Giải trình:

Ｅ…¹×⁺¹ＮＮ

Bản đồ trên phạm vi 1..H*(N+1) . Điều này có nghĩa là các bậc thang xuất hiện khi ilà bội số của H.

⪫

Tham gia kết quả của:

ＥＩζ

ánh xạ trên phạm vi ngầm 0..W:

⎇∧﹪ιＩη﹪λ⁻Ｉζ¹ 

nếu cột không 0hoặcW-1 và hàng không phải là bội số Hthì xuất ra một khoảng trắng;

§⮌γ‽⁹⁴

mặt khác, lấy biến ký tự ASCII được xác định trước, đảo ngược nó (đặt khoảng trắng ở vị trí thứ 94) và in một ký tự ngẫu nhiên từ cái hiện là 94 đầu tiên (Bởi vì Slice hút.)

ω

Tham gia sử dụng chuỗi trống. Kết quả cuối cùng được in ngầm.

C (gcc) , 141 131 114 109 107 byte

Có thể chơi golf này xuống một chút ...

i,j,c;f(w,h,n){for(i=1;i<h*n+h;i+=j==w)printf(i%h?i++,j=0,"%c%*c\n":"%c",++j^w?c^8:10,w-2,c=33+rand()%94);}

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

Perl 6 , 76 73 byte

->\h,\n,\w{map {chrs (roll(w,1..94)Z*1,|($_%%h xx w-2),1)X+32},1..^h*n+h}

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

Lấy (h, n, w) làm đối số. Trả về một danh sách các chuỗi.

Giải trình:

-> \h, \n, \w {  # Block taking arguments h, n, w
    map {
        # String from codepoints
        chrs
             # Generate w random numbers between 1 and 94
             (roll(w, 1..94)
              # Set inner numbers on non-rungs to zero
              Z* 1, |($_%%h xx w-2), 1)
             # Add 32 to numbers
             X+ 32
    }
    # Map h*n+h-1 row numbers (1-indexed)
    1..^h*n+h
}

PowerShell , 132 124 byte

param($w,$h,$n)-join([char[]]((($a=('#'+' '*($w-2)+"#`n")*--$h)+'#'*$w+"`n")*$n+$a)|%{($_,[char](33..126|Random))[$_-eq35]})

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

Chúng tôi xây dựng một thang gồm chỉ #đầu tiên ( ví dụ ), sau đó lặp |%{...}qua từng nhân vật và ifnó -equal tới 35, chúng tôi kéo ra một mới Randomnhân vật từ phạm vi thích hợp. Nếu không, chúng tôi đầu ra (nghĩa là một không gian hoặc dòng mới).

JavaScript (ES6), 117 115 byte

Một hàm đệ quy xây dựng ký tự đầu ra theo ký tự.

"Hãy nhìn Ma, không có nguồn cấp dữ liệu theo nghĩa đen!"

(w,h,n)=>(g=x=>y<h*n+h-1?String.fromCharCode(x++<w?x%w>1&&-~y%h?32:Math.random()*94+33|0:10)+g(x>w?!++y:x):'')(y=0)

Bản giới thiệu

let f =

(w,h,n)=>(g=x=>y<h*n+h-1?String.fromCharCode(x++<w?x%w>1&&-~y%h?32:Math.random()*94+33|0:10)+g(x>w?!++y:x):'')(y=0)

O.innerText = f(5,3,4)

<pre id=O></pre>

Python 2 , 142 byte

lambda w,h,n,e=lambda:chr(randint(33,126)):[e()+[eval(("e()+"*(w-2))[:-1])," "*(w-2)][-~i%h>0]+e()for i in range(h*-~n-1)]
from random import*

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

Lưu byte nhờ vào ovs!

Bình thường, 33 byte

VhEjtW!Nmsm?&d}kr1tQ\ Or\!C127Qvz

Dùng thử trực tuyến: Trình diễn

Python 2 , 114 byte

lambda w,h,n:[[chr(32+randint(1,94)*(x%~-w*(y%h)<1))for x in range(w)]for y in range(1,h*-~n)]
from random import*

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

SOGL V0.12 , 32 31 byte

 ~ΔkψR
I{e{R}¶bH{Re⁾⌡@R¶}}¹∑e⌡k

Hãy thử nó ở đây!

Nhập theo thứ tự N, W, H.

Giải trình:

 ~ΔkψR

     R  a function named "R", pushes a random character:
 ~       push "~"
  Δ      get the charasters from " " to "~"
   k     remove the 1st character
    ψ    choose a random character from that

I{e{R}¶bH{Re⁾⌡@R¶}}¹∑e⌡k  main program

I                         increase the 1st input - N
 {                }       N times do
  e                         push the variable e, which is here initialised to the next input - W
   { }                      E times do
    R                         execute R
      ¶                     push a newline
       bH                   push b-1, where b is initialised to the next input - H
         {       }          B-1 times do
          R                   execute R
           e⁾                 push e-2 aka width-2
             ⌡@               push that many spaces
               R              execute R
                ¶             push a newline
                   ¹∑     join the stack together
                     e⌡k  remove the first width characters

18 byte không có ký tự ngẫu nhiên: /

Java 8, 203 188 168 133 132 130 128 126 byte

W->H->N->{for(double i=0,j,q;++i<H*N+H;)for(j=W,q=10;j-->=0;q=i%H*j<1|j>W-2?33+Math.random()*94:32)System.out.print((char)q);}

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

Haskell , 226 220 211 190 byte

import System.Random
a=mapM id
b=(putStr.unlines=<<).a
c=randomRIO('!','~')
r w=a$c<$[1..w]
s w=a$c:(return ' '<$[3..w])++[c]
(w#h)0=b$s w<$[2..h]
(w#h)n=do{b$(s w<$[2..h])++[r w];(w#h)$n-1}

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

Đã lưu 9 byte nhờ Laikoni

Đã lưu 21 byte nhờ vào wchargein

Nên chơi golf ( b$(s w)<$[2..h]và b$((s w)<$[2..h])++[r w]). Tôi không cảm thấy thoải mái với IO và chơi gôn.

JavaScript (ES6), 144 byte

(w,h,n)=>Array(n+1).fill(("#".padEnd(w-1)+`#
`).repeat(h-1)).join("#".repeat(w)+`
`).replace(/#/g,_=>String.fromCharCode(33+Math.random()*94|0))

Tạo các bậc thang trong số các #ký tự sau đó thay thế từng cái bằng một char ASCII ngẫu nhiên.

Kiểm tra đoạn trích

let f=
(w,h,n)=>Array(n+1).fill(("#".padEnd(w-1)+`#
`).repeat(h-1)).join("#".repeat(w)+`
`).replace(/#/g,_=>String.fromCharCode(33+Math.random()*94|0))

;(W.oninput=H.oninput=N.oninput=B.onclick=_=>{let vals=[W.value,H.value,N.value].map(eval);D.innerText=vals.join`, `;O.innerText=f(...vals);})()

W: <input id=W type=range min=3 max=25 value=12><br>
H: <input id=H type=range min=2 max=25 value=5><br>
N: <input id=N type=range min=2 max=10 value=2><br>
<button id=B>Rerun</button> <code id=D></code>
<pre id=O></pre>

JavaScript (ES6), 129 117 byte

Thật không may, trong khi tôi đang chơi gôn, Arnauld đã đánh bại tôi với một giải pháp tương tự nhưng ngắn hơn . Bằng cách kết hợp 2 giải pháp của chúng tôi, đây có thể là 113 byte

Bao gồm một dòng mới.

(w,h,n)=>(g=c=>l?(c++<w?c%w>1&&l%h?` `:String.fromCharCode(94*Math.random()+33|0):`
`)+g(c>w?!--l:c):``)(0,l=h*++n-1)

Thử nó

o.innerText=(f=
(w,h,n)=>(g=c=>l?(c++<w?c%w>1&&l%h?` `:String.fromCharCode(94*Math.random()+33|0):`
`)+g(c>w?!--l:c):``)(0,l=h*++n-1)
)(i.value=5,j.value=3,k.value=2);oninput=_=>o.innerText=f(+i.value,+j.value,+k.value)

label,input{font-family:sans-serif;font-size:14px;height:20px;line-height:20px;vertical-align:middle}input{margin:0 5px 0 0;padding:0 0 0 5px;width:100px;}

<label for=i>W: </label><input id=i min=3 type=number><label for=j>H: </label><input id=j min=2 type=number><label for=k>N: </label><input id=k min=2 type=number><pre id=o>

Japt -R , 42 41 40 37 34 28 25 byte

Đưa đầu vào theo thứ tự H,W,N.

;*°WÉ ÆJ²ùVXgJùU¹r,@EÅöÃé

Thử nó

QBIC , 76 byte

[:*:+b-1|G=chr$(_r33,126|)~a%b\[:-2|G=G+@ `]][e|G=G+chr$(_r33,126|)]?_sG,1,e

Giải trình

[                       FOR a = 1 TO
 :                         input 1 (Height, now in var b)
  *                        times
   :                       input 2 (# of rungs, now in var c)
    +b-1|                  plus one bottom rung without crossbar
G=chr$(_r33,126|)       Assign to G a random char (_r is the RAND() function, chr$() is BASIC's num-to-char)
~a%b|                   IF we are not at a crossbar (the modulo returns anything but 0), 
  [:-2|G=G+@ `            add to G x spaces, where x is width (input 3, now 'e') - 2
                        Note that G is now either 'X' or 'X   '  (for rnd char X and W=5)
]]                      Close the spacing FOR, close the IF 
[e|                     FOR f = 1 to width
  G=G+chr$(_r33,126|)]     Append to G a rnd char
                        G is now either 'XXXXXX'  or 'X   XXXXX' (for rnd char X and W=5)
?_sG,1,e                PRINT the first w characters of G, and on to the next line

Chạy mẫu

Command line: 3 2 5
N   F
M   `
Bj#=y
!   (
S   N
q(.Ho
%   7
g   ,

MATL , 63 50 byte

-13 byte nhờ Luis Mendo

Q*qXJ*6Y2HY)wT3$ZrJ3G3$eJ3G&Ol5LZ(J:HG\~3GTX"!+g*c

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

Tôi vẫn chưa quen với việc chơi golf trong MATL (và tôi không giỏi về MATLAB cho vấn đề đó), vì vậy tôi biết điều này có lẽ không gần với tối ưu. Lời khuyên được chào đón. Đưa đầu vào theo thứ tựN,H,W .

Ở đây chúng tôi đi:

Q*qXJ                     # compute H*(N+1)-1, store as J
     *                    # multiply by W
      6Y2HY)              # push printable ASCII
            wT3$Zr        # sample uniformly with replacement
                  J3G3$e  # reshape to make a matrix of the appropriate shape.

Bây giờ chúng ta có một ma trận char ngẫu nhiên.

J3G                       # push J,W
   &O                     # zero matrix, J x W
     l5LZ(                # assign 1 to first and last columns

Bây giờ cũng có một ma trận logic cho đường ray.

J:                        # push J, range, so 1...J
  HG                      # take second input (H)
    \~                    # mod and bool negate (so it's 1 for rows of multiples of H)
      3GTX"!              # repmat and transpose so we have 1's for rungs

Bây giờ chúng ta có 3 ma trận trên ngăn xếp:

• Top: 0 cho non-rung, 1 nếu không
• Giữa: 0 cho phi đường sắt, 1 nếu không
• Dưới cùng: ký tự ngẫu nhiên, -20

Vì vậy, chúng tôi làm như sau:

+                         # add the top two matrices.
 g                        # convert to logical so 0->0, nonzero->1
   *                      # elementwise multiply
    c                     # convert to char, implicit output (0 -> space).

Powershell, 102 byte

param($w,$h,$n)1..(++$n*$h-1)|%{$l=$_%$h
-join(1..$w|%{[char](32,(33..126|Random))[!$l-or$_-in1,$w]})}

Kịch bản kiểm tra ít chơi gôn hơn:

$f = {

param($w,$h,$n)
1..(++$n*$h-1)|%{       # for each lines of the ladder
    $l=$_%$h            # line number in a step
    -join(1..$w|%{      # make a line
        [char](32,(33..126|Random))[!$l-or$_-in1,$w]
    })                  # a random character if the line number in a step is a rung line or char position is 1 or width
                        # otherwise a space
}

}

&$f 5 3 2
&$f 3 2 2
&$f 12 4 5
&$f 20 5 3

Đầu ra:

0   {
H   S
']UxR
G   ]
3   t
q^R8O
q   y
t   J
U h
YQZ
_ i
3#D
I #
=          m
&          <
]          6
8nmuyw2'Y7%+
o          l
;          !
D          M
Fn[zGfT";RYt
@          B
$          e
z          @
@J[1|:-IS~y<
(          L
:          [
|          q
zBow0T0FnY8)
/          *
e          B
R          p
9{d2(RacBdRj
u          ~
`          l
J          h
v                  t
T                  -
v                  H
'                  Y
IS7{bx2&k@u7]o}>[Vq?
F                  U
?                  U
|                  Q
}                  T
:wv1wEfc6cS;430sigF|
<                  L
:                  }
*                  `
H                  =
L8k5Q/DQ=0XIUujK|c6|
j                  =
!                  p
V                  :
#                  w

Ruby , 71 byte

EDIT: Rất tiếc tôi nghĩ rằng đây là một thử thách mới vì lần chỉnh sửa gần đây để sửa lỗi đánh máy lol. Tôi vẫn để lại điều này mặc dù chưa có câu trả lời cho Ruby.

->w,h,n{(1..h*-~n-1).map{|i|[*?!..?~].sample(x=i%h>0?2:w)*(' '*(w-x))}}

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