Chaos es una escalera ASCII

43

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    
Luis Mendo
fuente
¿Puedes agregar el rango (numérico) para los caracteres ascii?
Rod
@ Rod Buena idea. Hecho
Luis Mendo el
1
¿Qué tipo de límite inferior de calidad de aleatoriedad existe? Supongo que comenzar en un punto aleatorio y aumentar el módulo (126-33) no calificaría debido a la correlación obvia entre los valores adyacentes. ¿O tiene que ser capaz de producir todas las secuencias posibles? (¿Entonces un generador congruencial lineal de 8 bits no funcionaría, porque un personaje determina de manera única al siguiente personaje?)
Peter Cordes
@PeterCordes No hay ningún problema con tener alguna correlación, siempre y cuando pueda ocurrir cualquier combinación posible. El enfoque que describe es, como usted dice, no válido porque introduce una dependencia estadística demasiado fuerte entre los personajes en diferentes posiciones, haciendo que algunas combinaciones sean imposibles
Luis Mendo
1
@PeterCordes Sí, quise decir teóricamente. No te preocupes por la fuerza de RNG; puedes asumir que el RNG es ideal. Hay algún meta consenso sobre eso. Pensé que había algo más específico, pero todo lo que pude encontrar fue esto y esto
Luis Mendo

Respuestas:

6

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
Jonathan Allan
fuente
34

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
}
Steadybox
fuente
Parece que "\n"funciona, ¿ "\xa3"obtener algo así £no funciona? Si puede usar escapes Unicode, podría recortar esa matriz suya.
Tschallacka
¿Cómo puedo ejecutar esto yo mismo? : D
Geeky I
22
Esto solo parece que se escribió un guión y se eliminaron los espacios y las nuevas líneas. ¿Es solo obtener votos a favor debido a la imagen de una escalera o me he perdido un poco de golf inteligente?
Jonathan Allan
@steadybox, ¿está usando capturas de pantalla contextuales ahora después de que solicité una captura de pantalla que no sea de pastizales en esa pregunta xD?
Urna de pulpo mágico
@Tschallacka \nes el único escape que se reconoce. (Y ""entre comillas para representar uno ")
Steadybox
14

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
Emigna
fuente
Esto es un poco tramposo.
vdegenne
44
@ user544262772 ¿por qué?
Jonathan Allan
¿Puedes explicar esto un poco?
Mischa
@MischaBehrend: Claro, he agregado una explicación ahora.
Emigna
3
@ user544262772 puede ser bastante desafiante hacer una respuesta bien escrita en un lenguaje de golf, créanme, están diseñados para jugar al golf, pero usarlos generalmente requiere cierta reflexión (a menos que sea solo "aquí hay un incorporado que hace exactamente lo que usted quiere"). ").
Jonathan Allan
13

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);}
orlp
fuente
8

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

Giuseppe
fuente
m[-H*(1:N),3:W-1]=" "parece un poco más corto: siempre puede reemplazar las pruebas rowy colcon un corte en 2-d.
Neal Fultz
@NealFultz wow, eso es bastante excelente! ¡Gracias!
Giuseppe
-1 byte reemplazando sample(33:126,...)con 32+sample(94,...).
Robin Ryder
6

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!

Dom Hastings
fuente
el espacio después de \ d + puede ser eliminado debido a un partido codicioso
Nahuel Fouilleul
6

Carbón , 34 32 bytes

E…¹×⁺¹NN⪫EIζ⎇∧﹪ιIη﹪λ⁻Iζ¹ §⮌γ‽⁹⁴ω

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:

E…¹×⁺¹NN

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:

EIζ

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

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

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.

Neil
fuente
No estoy seguro de si es útil, pero podría dibujar la escalera y luego mirar y mapear sobre imprimible al azar, creo. EDITAR Parece estar roto. Ups
Solo ASCII
Intentaré solucionarlo (estoy bastante seguro de que funcionaba antes), pero he estado un poco ocupado, por lo que podría llevar un tiempo
solo ASCII el
@ Solo ASCII ¿Supongo que estás pensando NθGH↓θ→N↑θ*‖O↓F⁻N¹C⁰θ¿EKA§⮌γ‽⁹⁴«? Bueno, me bisequé y cometí lo a0a6316rompí.
Neil
@ Solo ASCII En realidad, eso no es del todo cierto, hubo un error no relacionado en el lugar Mapdonde se usaba not is_commandcuando se refería is_command. Entonces se suponía que escribirías NθGH↓θ→N↑θ*‖O↓F⁻N¹C⁰θUMKA§⮌γ‽⁹⁴si no hubiera sido por ese error.
Neil
6

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!

cleblanc
fuente
podemos editar i=1en la declaración global?
Mukul Kumar
6

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
}
nwellnhof
fuente
Alternativa 73 byter usando xxy en ++$lugar de map. ¿Quizás puedas encontrar un lugar para jugar golf en cualquier bytes?
Jo King
5

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

AdmBorkBork
fuente
5

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

Arnauld
fuente
¡Maldición! Estaba en el proceso de jugar al golf cuando vi esto. :\ ¡Ganaste de nuevo! : p
Shaggy
Terminé de jugar golf en el mío (por ahora): dibujé la línea al mover todos los ternarios dentro String.fromCharCode, ya que no podía decir honestamente que se me ocurriría eso después de ver esto. Avísame si sientes que el mío ahora es muy similar al tuyo.
Shaggy
@ Shaggy ¡No te preocupes! (En realidad, vi su respuesta solo después de publicar la mía. Si la hubiera visto antes, probablemente me habría dado por vencido.)
Arnauld
1
¡Ah, es la naturaleza del juego! :) La combinación de nuestras soluciones da 113 bytes , por cierto
Shaggy
5

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!

Sr. Xcoder
fuente
@LuisMendo Creo que lo arreglé ahora.
Sr. Xcoder
@LuisMendo Es mi culpa por no verificar cuidadosamente.
Sr. Xcoder
42 bytes
ovs
@ovs Gracias! Sin 1embargo, olvidó un en el frente> _>
Sr. Xcoder
4

Pyth, 33 bytes

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

Pruébelo en línea: demostración

Jakube
fuente
3

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!

Lynn
fuente
3

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: /

dzaima
fuente
3

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!

Roberto Graham
fuente
133 bytes:W->H->N->{for(int i=0,j;i++<H*N+H-1;){char c=10;for(j=W;j-->0;c=i%H<1|j>W-2|j<2?(char)(Math.random()*94+33):32)System.out.print(c);}}
Nevay
Actualmente está imprimiendo el resultado W-1, el bucle interno debe realizar una iteración adicional ( >=0+1 byte).
Nevay
1
132 bytes:W->H->N->{for(int i=0,j;i++<H*N+H-1;){char c=10;for(j=W;j-->=0;c=i%H*j<1|j>W-2?(char)(Math.random()*94+33):32)System.out.print(c);}}
Nevay
2
;++i<H*N+H;: -2 bytes.
Olivier Grégoire
3

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.

jferard
fuente
Se puede utilizar la notación infija para t w h n= ...: (w#h)n= .... purese puede usar en lugar de return. Puedes soltar los paréntesis (d ' ')<$y (s w)<$.
Laikoni
@Laikoni ¡No olvidaré la notación infija la próxima vez! Gracias.
jferard
1
Ahorre un montón de bytes con c=randomRIO('!','~'), que también le permite en línea d=return. Además, mapM ides un byte más corto que sequence.
wchargin
1
@wchargin Gracias. ¡Aprendí algo hoy!
jferard
2

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

Justin Mariner
fuente
String.fromCharCodey Math.randomen una solución: ¿por qué JavaScript nos odia? Se le ocurrió esto para 137 bytes, que es muy similar al suyo, solo que sin la matriz. Ahora me pregunto si una solución recursiva podría ser aún más corta; investigará más tarde.
Shaggy
2

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>

Lanudo
fuente
2

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

Lanudo
fuente
1

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   ,
Steenbergh
fuente
1

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).
Giuseppe
fuente
Aquí hay algunos consejos rápidos: X"es 3$por defecto. 6Y2puede ser útil en lugar de 13:106... 20+. ~~es g. J3G&Ol5LZ(se puede usar en lugar de1F3G2-Y"h1hJT3$X"
Luis Mendo
@LuisMendo Ah, no pude leer todos los documentos o lo habría descubierto X". En ese último consejo, 5Les [1 0]pero no estoy seguro de cómo que se utiliza en conjunción con Z(- consigo que se está asignando 1a la primera y última columnas pero no entiendo cómo 5LZ(logra eso. Probablemente te haga un ping en MATL CHATL más adelante sobre esto, así que no te preocupes por eso por ahora.
Giuseppe
1
La indexación es modular, por lo que 0es lo mismo que "fin". Z(asigna a las columnas. Por supuesto, ¡no dudes en enviarme un ping en el chat!
Luis Mendo
1

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
mazzy
fuente
1

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!

Tinta de valor
fuente