No sabes nada. Lo que hago por " Chaos is a ladder " es una frase memorable de la serie de televisión Game of Thrones .

El propósito de este desafío es construir una escalera desde el caos, en el arte ASCII.

El reto

Entrada

• Ancho de escalera W >= 3(entero)
• Altura del paso, H >= 2(entero)
• Número de peldaños, N >= 2(entero).

Salida

Una escalera con peldaños horizontales y rieles verticales , todos de 1 carácter de ancho. El ancho de la escalera ( W) incluye los dos rieles, y la altura del escalón ( H) incluye el peldaño correspondiente.

Todos los peldaños, incluidos el superior y el inferior, tendrán un trozo de riel vertical de longitud H-1directamente arriba y abajo. El ejemplo aclarará esto.

La escalera estará hecha de caracteres ASCII imprimibles que no sean espacios en blanco , es decir, el rango inclusivo de !(punto de código 33) a ~(punto de código 126). Los caracteres reales se elegirán aleatoriamente . Dadas las entradas, cada una de las elecciones aleatorias de caracteres debe tener una probabilidad distinta de cero. Aparte de eso, la distribución de probabilidad es arbitraria.

Se permite el espacio en blanco inicial o final , ya sea horizontal o vertical.

Ejemplo

Dado W=5, H=3, N=2, una salida posible es la siguiente.

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

Tenga en cuenta que la altura total es H*(N+1)-1, ya que hay Npeldaños y N+1secciones verticales.

Reglas adicionales

• Los medios de entrada y el formato son flexibles como de costumbre. Por ejemplo, puede ingresar los tres números en cualquier orden, o una matriz que los contenga.

• La salida puede ser a través de STDOUT o un argumento devuelto por una función. En este caso, puede ser una cadena con nuevas líneas, una matriz de caracteres 2D o una matriz de cadenas.

• Se puede proporcionar un programa o una función .

• Las lagunas estándar están prohibidas.

• El código más corto en bytes gana.

Casos de prueba

Para cada W, H, Nuno se muestra una salida posible.

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    

Jalea ,  24 23  22 bytes

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

Un programa completo de tomar los tres argumentos W, H, Ne imprimir el resultado.

Pruébalo en línea!

¿Cómo?

Construye una máscara de matriz 2D de un solo peldaño y sus secciones verticales a continuación, la repite N+1veces y elimina el peldaño superior y luego coloca caracteres o espacios al azar dependiendo del valor de la 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

Lenguaje de script Operation Flashpoint , 643624 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}

Ridículamente largo porque no hay forma de crear los personajes a partir de los códigos de caracteres.

Llamar con:

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

Salida:

La escalera es extra caótica porque la fuente no es monoespaciada.

Desenrollado:

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 tomada en el pedido N, H, W

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

Pruébalo en línea!

Explicación

>*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 gracias a Neal Fultz!

-1 byte gracias 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}

Pruébalo en línea!

Función anónima; devuelve el resultado como una matriz.

Gracias a esa pregunta de Word Grids , he estado pensando en matrices mucho más de lo habitual. Observé que los peldaños están en esas filas de la matriz que son múltiplos de la altura del escalón H(R está indexada en 1), y que los rieles son la primera y la última columna, 1y W. Así que creo una matriz de caracteres ASCII aleatorios, y reemplazo esas letras que no coinciden con esos criterios con espacios, y devuelvo la matriz. El enlace TIO lo imprime muy bien.

Neal Fultz sugirió una indexación diferente para los caracteres de espacio [-H*(1:N),3:W-1], que reemplaza todos los caracteres excepto aquellos en filas de múltiplos de H: -H*(1:N)y no en el borde, 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")}

Pruébalo en línea!

Una mejora sobre el enfoque original basado en matriz con el que comencé; es el mismo algoritmo, pero los forbucles son más cortos que construir e imprimir una matriz (¡pero no si no lo imprimo!)

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

Pruébalo en línea!

Carbón , 34 32 bytes

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

Pruébalo en línea! Toma datos en el orden N, H, W. Aproximación detallada ( Plus(InputNumber(), 1)actualmente está interrumpida en TIO). Explicación:

Ｅ…¹×⁺¹ＮＮ

Mapa sobre el rango 1..H*(N+1). Esto significa que los peldaños aparecen cuando ies un múltiplo de H.

⪫

Únete al resultado de:

ＥＩζ

mapeo sobre el rango implícito 0..W:

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

si la columna no es 0o W-1y la fila no es múltiplo de, Hentonces genera un espacio;

§⮌γ‽⁹⁴

de lo contrario, tome la variable de caracteres ASCII predefinida, inviértala (colocando el espacio en el lugar 94) e imprima un carácter aleatorio de lo que ahora es el primer 94. (Porque Sliceapesta).

ω

Únase usando la cadena vacía. El resultado final se imprime implícitamente.

C (gcc) , 141 131 114 109 107 bytes

Debería poder jugar golf un poco ...

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

Pruébalo en línea!

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}

Pruébalo en línea!

Toma (h, n, w) como argumentos. Devuelve una lista de cadenas.

Explicación:

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

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

Pruébalo en línea!

Construimos una escalera compuesta solo por el #primero ( ejemplo ), luego recorremos |%{...}cada personaje y ifes -eqnormal 35, sacamos un nuevo Randompersonaje del rango apropiado. De lo contrario, damos salida (es decir, ya sea un espacio o una nueva línea).

JavaScript (ES6), 117115 bytes

Una función recursiva que construye la salida carácter por carácter.

"¡Mira mamá, no hay salto de línea literal!"

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

Manifestación

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*

Pruébalo en línea!

Bytes guardados gracias a ovs!

Pyth, 33 bytes

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

Pruébelo en línea: demostración

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*

Pruébalo en línea!

SOGL V0.12 , 32 31 bytes

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

Pruébalo aquí!

Ingrese en el orden N, W, H.

Explicación:

 ~Δ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 sin los caracteres aleatorios: /

Java 8, 203 188 168 133 132 130 128 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);}

Pruébalo en línea!

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}

Pruébalo en línea!

Guardado 9 bytes gracias a Laikoni

Guardado 21 bytes gracias a wchargin

Debe ser golfable ( b$(s w)<$[2..h]y b$((s w)<$[2..h])++[r w]). No me siento cómodo con IO y el golf.

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

Crea la escalera con #caracteres y luego reemplaza cada uno con un carácter ASCII aleatorio.

Fragmento de prueba

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), 129117 bytes

Desafortunadamente, mientras estaba en el proceso de jugar golf, Arnauld me ganó con una solución similar pero más corta . Al combinar nuestras 2 soluciones, esto puede ser 113 bytes

Incluye una nueva línea final.

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

Intentalo

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

Toma entrada en el orden H,W,N.

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

Intentalo

QBIC , 76 bytes

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

Explicación

[                       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

Ejecución de la muestra

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

MATL , 63 50 bytes

-13 bytes gracias a Luis Mendo

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

Pruébalo en línea!

Todavía soy nuevo en el golf en MATL (y no soy súper bueno en MATLAB para el caso), así que sé que esto probablemente no está cerca de lo óptimo. Las propinas son bienvenidas. Toma entrada en orden N,H,W.

Aquí vamos:

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.

Ahora tenemos una matriz de caracteres aleatorios.

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

Ahora también hay una matriz lógica para los rieles.

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

Ahora tenemos 3 matrices en la pila:

• Arriba: 0 para no peldaño, 1 de lo contrario
• Medio: 0 para no ferroviario, 1 de lo contrario
• Abajo: caracteres aleatorios, -20

Entonces hacemos lo siguiente:

+                         # 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]})}

Menos guión de prueba de golf:

$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

Salida:

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

EDITAR: Vaya, pensé que este era un nuevo desafío debido a la edición reciente para corregir un error tipográfico. Sin embargo, todavía lo dejo porque todavía no hay una respuesta de Ruby.

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

Pruébalo en línea!