Você não sabe nada As coisas que faço para " Chaos is a ladder " são uma frase memorável da série de televisão Game of Thrones .

O objetivo deste desafio é construir uma escada do caos, na arte ASCII.

O desafio

Entrada

• Largura da escada, W >= 3(inteiro)
• Altura do passo, H >= 2(inteiro)
• Número de linhas, N >= 2(inteiro).

Resultado

Uma escada com degraus horizontais e trilhos verticais , com 1 caractere de largura. A largura da escada ( W) inclui os dois trilhos e a altura do degrau ( H) inclui o degrau correspondente.

Todos os degraus, incluindo o superior e o inferior, terão um trilho vertical de comprimento H-1diretamente acima e abaixo. O exemplo tornará isso mais claro.

A escada será feita de caracteres ASCII imprimíveis e sem espaço em branco , ou seja, o intervalo inclusivo de !(ponto de código 33) a ~(ponto de código 126). Os caracteres reais serão escolhidos aleatoriamente . Dadas as entradas, cada uma das opções aleatórias de caracteres deve ter probabilidade diferente de zero. Fora isso, a distribuição de probabilidade é arbitrária.

Espaços em branco à esquerda ou à direita , horizontais ou verticais, são permitidos.

Exemplo

Dado W=5, H=3, N=2, uma saída possível é a seguinte.

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

Observe que a altura total é H*(N+1)-1, pois existem Ndegraus e N+1seções verticais.

Regras adicionais

• Os meios e o formato de entrada são flexíveis, como de costume. Por exemplo, você pode inserir os três números em qualquer ordem ou em uma matriz que os contenha.

• A saída pode ser através de STDOUT ou um argumento retornado por uma função. Nesse caso, pode ser uma sequência com novas linhas, uma matriz de caracteres 2D ou uma matriz de cadeias.

• Um programa ou uma função pode ser fornecida.

• As brechas padrão são proibidas.

• O menor código em bytes vence.

Casos de teste

Para cada W, H, Numa, uma saída possível é mostrada.

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    

Gelatina ,  24 23  22 bytes

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

Um programa completo de tomar os três argumentos W, H, Ne imprimir o resultado.

Experimente online!

Quão?

Constrói uma máscara de matriz 2D de uma única linha e suas seções verticais abaixo, repete-a N+1vezes e remove a linha superior e coloca caracteres ou espaços aleatórios, dependendo do valor da máscara.

«þỊ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

Linguagem de script da operação Flashpoint , 643 624 bytes

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}

Ridiculamente longo, porque não há como criar os caracteres a partir dos códigos de caracteres.

Ligue para:

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

Resultado:

A escada é extremamente caótica porque a fonte não é monoespaçada.

Desenrolado:

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 bytes

Entrada feita na ordem N, H, W

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

Experimente online!

Explicação

>*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 bytes

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 bytes

-13 bytes graças a Neal Fultz!

-1 byte graças a 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}

Experimente online!

Função anônima; retorna o resultado como uma matriz.

Graças a essa pergunta do Word Grids , estive pensando em matrizes muito mais do que o habitual. Observei que os degraus estão nessas linhas da matriz que são um múltiplo da altura do degrau H(R é indexado em 1) e que os trilhos são a primeira e a última coluna, 1e W. Portanto, crio uma matriz de caracteres ASCII aleatórios, substituo as letras que não correspondem a esses critérios por espaços e retorno a matriz. O link TIO imprime bem.

Neal Fultz sugeriu uma indexação diferente para os caracteres de espaço [-H*(1:N),3:W-1], que substitui todos os caracteres, exceto aqueles em linhas de múltiplos de H: -H*(1:N)e não na borda, 3:W-1<==> 2:(W-1).

R , 121 bytes

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

Experimente online!

Uma melhoria em relação à abordagem original baseada em matriz com a qual comecei; é o mesmo algoritmo, mas os forloops são mais curtos do que construir e imprimir uma matriz (mas não se eu não imprimi-lo!)

Perl 5 , 81 bytes

Código de 80 bytes + 1 para -p.

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

Experimente online!

Carvão , 34 32 bytes

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

Experimente online! Toma entrada na ordem N, H, W. Aproximação detalhada ( Plus(InputNumber(), 1)atualmente está interrompida no TIO). Explicação:

Ｅ…¹×⁺¹ＮＮ

Mapa acima do intervalo 1..H*(N+1). Isso significa que as linhas aparecem quando ié múltiplo de H.

⪫

Junte-se ao resultado de:

ＥＩζ

mapeamento sobre o intervalo implícito 0..W:

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

se a coluna não é 0ou W-1e a linha não é um múltiplo, em Hseguida, gera um espaço;

§⮌γ‽⁹⁴

caso contrário, pegue a variável de caractere ASCII predefinida, inverta-a (colocando o espaço em 94º lugar) e imprima um caractere aleatório do que agora é o primeiro 94. (Porque Sliceé uma merda.)

ω

Associe-se usando a string vazia. O resultado final é impresso implicitamente.

C (gcc) , 141 131 114 109 107 107 bytes

Deve ser capaz de jogar isso um pouco ...

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

Experimente online!

Perl 6 , 76 73 bytes

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

Experimente online!

Toma (h, n, w) como argumentos. Retorna uma lista de strings.

Explicação:

-> \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 bytes

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

Experimente online!

Construímos uma escada composta de apenas #primeiro ( exemplo ), então circuito |%{...}através de cada personagem e ifque de -equal a 35, nós retiramos um novo Randompersonagem a partir do intervalo apropriado. Caso contrário, produzimos (ou seja, um espaço ou nova linha).

JavaScript (ES6), 117 115 bytes

Uma função recursiva que cria o caractere de saída por caractere.

"Olhe Ma, sem alimentação literal de linha!"

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

Demo

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 bytes

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*

Experimente online!

Bytes salvos graças a ovs!

Pitão, 33 bytes

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

Experimente online: Demonstração

Python 2 , 114 bytes

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*

Experimente online!

SOGL V0.12 , 32 31 bytes

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

Experimente aqui!

Entrada na ordem N, W, H.

Explicação:

 ~Δ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 bytes sem os caracteres aleatórios: /

Java 8, 203 188 168 133 133 130 130 126 126 bytes

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

Experimente online!

Haskell , 226 220 211 190 bytes

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}

Experimente online!

Guardado 9 bytes graças a Laikoni

Economizou 21 bytes graças a wchargin

Deve ser jogável ( b$(s w)<$[2..h]e b$((s w)<$[2..h])++[r w]). Não me sinto confortável com IO e golfe.

JavaScript (ES6), 144 bytes

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

Cria a escada de #caracteres e substitui cada um por um caractere ASCII aleatório.

Snippet de teste

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 bytes

Infelizmente, enquanto eu estava jogando golfe, Arnauld me derrotou em uma solução semelhante, mas mais curta . Ao combinar nossas 2 soluções, isso pode ter 113 bytes

Inclui uma nova linha à direita.

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

Tente

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 bytes

Recebe entrada na ordem H,W,N.

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

Tente

QBIC , 76 bytes

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

Explicação

[                       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

Amostra de execução

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

MATL , 63 50 bytes

-13 bytes graças a Luis Mendo

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

Experimente online!

Ainda sou novo no golfe no MATL (e não sou muito bom no MATLAB), então sei que isso provavelmente não está próximo do ideal. Dicas são bem vindas. Leva a entrada em ordem N,H,W.

Aqui vamos nós:

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.

Agora temos uma matriz de caracteres aleatórios.

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

Agora também há uma matriz lógica para os trilhos.

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

Agora temos 3 matrizes na pilha:

• Superior: 0 para não degraus, 1 caso contrário
• Meio: 0 para não ferroviário, 1 caso contrário
• Abaixo: caracteres aleatórios, -20

Então, fazemos o seguinte:

+                         # 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 bytes

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

Script de teste com menos golfe:

$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

Resultado:

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 bytes

Edição: Opa, eu pensei que este era um novo desafio por causa da edição recente para corrigir um erro de digitação lol. Ainda estou deixando isso para lá porque ainda não há resposta para Ruby.

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

Experimente online!