Il caos è una scala ASCII


43

Non sai nulla Le cose che faccio per " Chaos is a ladder " sono una linea memorabile della serie televisiva Game of Thrones .

Lo scopo di questa sfida è quello di costruire una scala dal caos, nell'arte ASCII.

La sfida

Ingresso

  • Larghezza scala W >= 3(intero)
  • Altezza del gradino, H >= 2(intero)
  • Numero di pioli, N >= 2(intero).

Produzione

Una scala con pioli orizzontali e binari verticali , tutti larghi 1 carattere. La larghezza della scala ( W) include i due binari e l'altezza del gradino ( H) include il ramo corrispondente.

Tutti i pioli, compreso quello più in alto e quello più in basso, avranno un pezzo di binario verticale di lunghezza H-1direttamente sopra e sotto. L'esempio renderà questo più chiaro.

La scala sarà composta da caratteri ASCII non stampabili, non bianchi , ovvero l'intervallo compreso tra !(punto di codice 33) e ~(punto di codice 126). I caratteri effettivi verranno scelti in modo casuale . Dati gli input, ciascuna delle scelte casuali di personaggi deve avere probabilità diverse da zero. A parte questo, la distribuzione delle probabilità è arbitraria.

Sono consentiti spazi bianchi iniziali o finali , sia orizzontali che verticali.

Esempio

Dato W=5, H=3, N=2, un possibile output è il seguente.

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

Si noti che l'altezza totale è H*(N+1)-1, in quanto vi sono Npioli e N+1sezioni verticali.

Regole Adizionali

  • I mezzi di input e il formato sono flessibili come al solito. Ad esempio, è possibile inserire i tre numeri in qualsiasi ordine o un array che li contiene.

  • L'output può essere tramite STDOUT o un argomento restituito da una funzione. In questo caso può essere una stringa con newline, una matrice di caratteri 2D o una matrice di stringhe.

  • È possibile fornire un programma o una funzione .

  • Sono vietate le scappatoie standard .

  • Vince il codice più breve in byte.

Casi test

Per ognuno W, H, Nviene mostrato un possibile output.

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    

puoi aggiungere l'intervallo (numerico) per i caratteri ASCII?
Rod,

@Rod Buona idea. Fatto
Luis Mendo, il

1
Che tipo di limite inferiore esiste sulla qualità della casualità? Suppongo che partire da un punto casuale e incrementare il modulo (126-33) non si qualificherebbe a causa dell'ovvia correlazione tra valori adiacenti. O deve essere in grado di produrre ogni possibile sequenza? (Quindi un generatore congruenziale lineare a 8 bit non funzionerebbe, perché un personaggio determina in modo univoco il carattere successivo?)
Peter Cordes,

@PeterCordes Non c'è alcun problema ad avere una certa correlazione, purché si possa verificare ogni possibile combinazione. L'approccio che descrivi non è, come dici tu, non valido perché introduce una dipendenza statistica troppo forte tra personaggi in posizioni diverse, rendendo impossibili alcune combinazioni
Luis Mendo

1
@PeterCordes Sì, intendevo teoricamente. Non preoccuparti della forza del GNN; puoi presumere che l'RNG sia l'ideale. C'è qualche meta consenso al riguardo. Pensavo ci fosse qualcosa di più specifico, ma tutto quello che ho potuto trovare era questo e questo
Luis Mendo,

Risposte:


6

Gelatina ,  24 23  22 byte

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

Un programma completo di prendere i tre argomenti W, H, Ne stampare il risultato.

Provalo online!

Come?

Costruisce una maschera di matrice 2d di un singolo ramo e le sue sezioni verticali sottostanti, lo ripete N+1volte e rimuove il ramo superiore, quindi posiziona caratteri casuali o spazi a seconda del valore della maschera.

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

34

Operazione linguaggio di scripting 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}

Ridicolmente lungo perché non c'è modo di creare i personaggi dai codici dei caratteri.

Chiama con:

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

Produzione:

La scala è molto caotica perché il carattere non è monospaziato.

srotolato:

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
}

Sembra che funzioni "\n", "\xa3"ottenere qualcosa come £non funziona? se puoi usare le escape unicode potresti essere in grado di tagliare quella tua matrice.
Tschallacka,

Come posso gestirlo da solo? : D
Geeky I

22
Sembra proprio che sia stata scritta una sceneggiatura e che gli spazi e le nuove righe siano stati rimossi. Sta solo ricevendo voti a causa di un'immagine di una scala o ho perso un po 'di golf intelligente?
Jonathan Allan,

@steadybox stai usando schermate contestuali ora dopo che ho richiesto uno screenshot non prateria su quella domanda xD?
Magic Octopus Urn,

@Tschallacka \nè l'unica via di fuga riconosciuta. (E ""dentro le virgolette per rappresentarne una ")
Steadybox

14

05AB1E , 29 byte

Input preso nell'ordine N, H, W

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

Provalo online!

Spiegazione

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

Questo è un po 'barare.
vdegenne,

4
@ user544262772 perché così?
Jonathan Allan,

potresti spiegarlo un po '?
Mischa,

@MischaBehrend: certo, ho aggiunto una spiegazione ora.
Emigna,

3
@ user544262772 può essere abbastanza impegnativo dare una risposta ben giocata in un linguaggio golfistico, credimi, sono progettati per giocare a golf, ma usarli di solito richiede qualche pensiero (a meno che non sia solo "ecco un built-in che fa esattamente quello che vuoi ").
Jonathan Allan,

13

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

8

R , 138 129 111 98 93 byte

-13 byte grazie a Neal Fultz!

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

Provalo online!

Funzione anonima; restituisce il risultato come matrice.

Grazie a quella domanda sulle griglie di parole , ho pensato alle matrici molto più del solito. Ho osservato che i pioli sono in quelle righe di matrice che sono un multiplo dell'altezza del gradino H(R è 1 indicizzato) e che i binari sono la prima e l'ultima colonna, 1e W. Quindi creo una matrice di caratteri ASCII casuali e sostituisco quelle lettere che non corrispondevano a quei criteri con spazi e restituisco la matrice. TIO link lo stampa bene.

Neal Fultz ha suggerito una diversa indicizzazione per i caratteri spaziali [-H*(1:N),3:W-1], che sostituisce tutti i caratteri tranne quelli in file di multipli di H: -H*(1:N)e non sul bordo, 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")}

Provalo online!

Un miglioramento rispetto all'approccio basato sulla matrice originale con cui ho iniziato; è lo stesso algoritmo ma i forloop sono più brevi della costruzione e della stampa di una matrice (ma non se non lo stampo!)


m[-H*(1:N),3:W-1]=" "sembra un po 'più breve: puoi sempre sostituire i test rowe colcon una porzione 2D.
Neal Fultz,

@NealFultz wow, è davvero eccellente! Grazie!
Giuseppe,

-1 byte sostituendo sample(33:126,...)con 32+sample(94,...).
Robin Ryder,


6

Carbone , 34 32 byte

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

Provalo online! Accetta input nell'ordine N, H, W. Approssimazione dettagliata (al Plus(InputNumber(), 1)momento è rotta su TIO). Spiegazione:

E…¹×⁺¹NN

Mappa sull'intervallo 1..H*(N+1). Ciò significa che i pioli appaiono quando iè un multiplo di H.

Partecipa al risultato di:

EIζ

mappatura sull'intervallo implicito 0..W:

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

se la colonna non è 0o W-1e la riga non è un multiplo di Hallora genera uno spazio;

§⮌γ‽⁹⁴

altrimenti, prendi la variabile di carattere ASCII predefinita, invertila (mettendo lo spazio al 94 ° posto) e stampa un carattere casuale da quello che ora è il primo 94. (Perché fa Sliceschifo.)

ω

Partecipa usando la stringa vuota. Il risultato finale viene stampato implicitamente.


Non so se è utile, ma si potrebbe trarre la scala e poi peekall e mappa su casuale stampabile penso? EDIT Sembra essere rotto. Ops.
ASCII,

Proverò a risolverlo (abbastanza sicuro che funzionasse prima) ma sono stato un po 'occupato, quindi potrebbe volerci un po'
ASCII il

@ ASCII-solo suppongo che stai pensando NθGH↓θ→N↑θ*‖O↓F⁻N¹C⁰θ¿EKA§⮌γ‽⁹⁴«? Bene, ho diviso in due e il commesso l'ha a0a6316rotto.
Neil,

@ ASCII-only In realtà non è del tutto vero, c'era un bug non correlato in Mapcui usava not is_commandquando voleva dire is_command. Quindi avresti dovuto scrivere NθGH↓θ→N↑θ*‖O↓F⁻N¹C⁰θUMKA§⮌γ‽⁹⁴se non fosse stato per quel bug.
Neil,

6

C (gcc) , 141 131 114 109 107 byte

Dovrebbe essere in grado di giocare a golf un po '...

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

Provalo online!


possiamo modificare i=1nella dichiarazione globale?
Mukul Kumar,

6

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}

Provalo online!

Prende (h, n, w) come argomenti. Restituisce un elenco di stringhe.

Spiegazione:

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

Alternativa 73 byter utilizzando xxe ++$invece di map. Forse puoi trovare un posto per giocare a golf fuori da ogni byte?
Jo King,

5

PowerShell , 132 124 byte

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

Provalo online!

Costruiamo una scala composta solo dal #primo ( esempio ), quindi eseguiamo il ciclo |%{...}attraverso ogni personaggio ed ifè -eqnormale 35, estraiamo un nuovo Randompersonaggio dall'intervallo appropriato. Altrimenti produciamo (ovvero uno spazio o una nuova riga).


5

JavaScript (ES6), 117 115 byte

Una funzione ricorsiva che crea l'output carattere per carattere.

"Guarda mamma, nessun feed letterale!"

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

dimostrazione


Accidenti! Ero in procinto di giocare a golf la mia quando ho visto questo. :\ Hai vinto nuovamente! : p
Shaggy,

Ho finito di giocare a golf con il mio (per ora) - Ho disegnato la linea per spostare tutti i ternari all'interno String.fromCharCode, dato che non potrei dire onestamente che mi sarei inventato dopo aver visto questo. Fammi sapere se ritieni che il mio sia troppo simile al tuo.
Shaggy,

@Shaggy Nessun problema! (In realtà, ho visto la tua risposta solo dopo aver pubblicato la mia. Se l'avessi vista prima, probabilmente avrei rinunciato.)
Arnauld

1
Ah, è la natura del gioco! :) La combinazione delle nostre soluzioni fornisce 113 byte , tra l'altro
Shaggy,




3

SOGL V0.12 , 32 31 byte

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

Provalo qui!

Inserire nell'ordine N, W, H.

Spiegazione:

 ~Δ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 senza i caratteri casuali: /


3

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

Provalo online!


133 byte: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,

Attualmente stai stampando il risultato per W-1, il ciclo interno deve eseguire un'iterazione aggiuntiva ( >=0+1 byte).
Nevay,

1
132 byte: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 byte.
Olivier Grégoire,

3

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}

Provalo online!

Salvataggio di 9 byte grazie a Laikoni

Risparmiato 21 byte grazie a wchargin

Dovrebbe essere golfabile ( b$(s w)<$[2..h]e b$((s w)<$[2..h])++[r w]). Non mi sento a mio agio con l'IO e il golf.


È possibile utilizzare la notazione infissa per t w h n= ...: (w#h)n= .... purepuò essere usato al posto di return. È possibile rilasciare le parentesi intorno (d ' ')<$e (s w)<$.
Laikoni,

@Laikoni Non dimenticherò la notazione infix la prossima volta! Grazie.
jferard,

1
Salvare un sacco di byte con c=randomRIO('!','~'), che ti consente anche in linea d=return. Inoltre, mapM idè un byte più breve di sequence.
wchargin,

1
@wchargin Grazie. Ho imparato qualcosa oggi!
jferard,

2

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

Crea la scala di #caratteri quindi sostituisce ciascuno con un carattere ASCII casuale.

Test dello snippet


String.fromCharCodee Math.randomin un'unica soluzione: perché JavaScript ci odia ?! È arrivato con questo per 137 byte, che è molto simile al tuo, solo senza l'array. Mi chiedo ora se una soluzione ricorsiva potrebbe essere ancora più breve; esaminerò più tardi.
Shaggy,


2

JavaScript (ES6), 129 117 byte

Sfortunatamente, mentre ero in procinto di giocare a golf, Arnauld mi ha battuto a una soluzione simile ma più breve . Combinando le nostre 2 soluzioni, questo può essere 113 byte

Include una nuova riga finale.

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

Provalo

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>


2

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

Accetta input nell'ordine H,W,N.

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

Provalo


1

QBIC , 76 byte

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

Spiegazione

[                       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

Esecuzione del campione

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

1

MATL , 63 50 byte

-13 byte grazie a Luis Mendo

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

Provalo online!

Sono ancora nuovo al golf in MATL (e non sono molto bravo in MATLAB per quella materia), quindi so che questo probabilmente non è vicino all'ottimale. I consigli sono benvenuti. Accetta l'input in ordine N,H,W.

Eccoci qui:

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.

Ora abbiamo una matrice di caratteri casuali.

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

Ora c'è anche una matrice logica per le rotaie.

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

Ora abbiamo 3 matrici in pila:

  • In alto: 0 per non gradino, 1 altrimenti
  • Centro: 0 per non-rail, 1 altrimenti
  • In basso: caratteri casuali, -20

Quindi facciamo quanto segue:

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

Ecco alcuni suggerimenti rapidi: X"è 3$di default. 6Y2può essere a portata di mano, invece di 13:106... 20+. ~~lo è g. J3G&Ol5LZ(può essere usato al posto di1F3G2-Y"h1hJT3$X"
Luis Mendo il

@LuisMendo Ah, non sono riuscito a superare tutti i documenti o l'avrei scoperto X". In quest'ultimo suggerimento, 5Lè , [1 0]ma non sono sicuro di come venga utilizzato insieme a Z(- Capisco che si sta assegnando 1alla prima e all'ultima colonna, ma non capisco come lo 5LZ(compia. Probabilmente ti chiamerò in MATL CHATL qualche tempo dopo, quindi non preoccuparti per ora.
Giuseppe,

1
L'indicizzazione è modulare, quindi 0è la stessa di "fine". Z(assegna alle colonne. Certo, sentiti libero di chiamarmi in chat!
Luis Mendo,

1

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

Script di test meno golfato:

$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

Produzione:

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

1

Rubino , 71 byte

EDIT: Oops Ho pensato che questa fosse una nuova sfida a causa della recente modifica per correggere un errore di battitura lol. Lo sto ancora lasciando, però, perché non c'è ancora una risposta di Ruby.

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

Provalo online!

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.