Du weißt nichts Die Dinge, die ich für " Chaos ist eine Leiter " tue, sind eine denkwürdige Zeile aus der Fernsehserie Game of Thrones .

Der Zweck dieser Herausforderung ist es, eine Leiter aus dem Chaos in ASCII-Kunst zu bauen.

Die Herausforderung

Eingang

• Leiterbreite W >= 3(Ganzzahl)
• Stufenhöhe H >= 2(ganze Zahl)
• Anzahl der Sprossen N >= 2(Ganzzahl).

Ausgabe

Eine Leiter mit horizontalen Sprossen und vertikalen Schienen , alle 1 Zeichen breit. Die Leiterbreite ( W) enthält die beiden Schienen, und die Stufenhöhe ( H) enthält die entsprechende Sprosse.

Alle Sprossen, einschließlich der obersten und der untersten, haben ein vertikales Schienenstück mit einer Länge H-1direkt darüber und darunter. Das Beispiel wird dies verdeutlichen.

Die Leiter besteht aus druckbaren ASCII-Zeichen (ohne Leerzeichen), dh dem Einschlussbereich von !(Codepunkt 33) bis ~(Codepunkt 126). Die tatsächlichen Zeichen werden nach dem Zufallsprinzip ausgewählt . In Anbetracht der Eingaben muss jede zufällige Auswahl von Zeichen eine Wahrscheinlichkeit ungleich Null haben. Ansonsten ist die Wahrscheinlichkeitsverteilung beliebig.

Führende oder nachfolgende Leerzeichen (horizontal oder vertikal) sind zulässig.

Beispiel

Vorausgesetzt W=5, H=3, N=2, eine mögliche Ausgabe ist wie folgt.

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

Beachten Sie, dass die Gesamthöhe gleich ist H*(N+1)-1, da es NSprossen und N+1vertikale Abschnitte gibt.

Zusätzliche Regeln

• Eingabemittel und Format sind wie gewohnt flexibel . Beispielsweise können Sie die drei Zahlen in einer beliebigen Reihenfolge oder in einem Array eingeben, das sie enthält.

• Die Ausgabe kann über STDOUT oder ein von einer Funktion zurückgegebenes Argument erfolgen. In diesem Fall kann es sich um eine Zeichenfolge mit Zeilenumbrüchen, ein 2D-Zeichenarray oder ein Array von Zeichenfolgen handeln.

• Ein Programm oder eine Funktion kann bereitgestellt werden.

• Standardlücken sind verboten.

• Kürzester Code in Bytes gewinnt.

Testfälle

Für jede wird W, H, Neine mögliche Ausgabe angezeigt.

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    

Jelly ,  24 23  22 Bytes

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

Ein volles Programm nehmen die drei Argumente W, H, Nund Druck das Ergebnis.

Probieren Sie es online!

Wie?

Erstellt eine 2D-Array-Maske aus einem einzelnen Strompfad und seinen vertikalen Abschnitten darunter, wiederholt sie N+1und entfernt den oberen Strompfad. Anschließend werden je nach Maskenwert zufällige Zeichen oder Leerzeichen eingefügt.

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

Operation Flashpoint Skriptsprache, 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}

Lächerlich lang, weil es keine Möglichkeit gibt, die Zeichen aus den Zeichencodes zu erstellen.

Rufen Sie an mit:

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

Ausgabe:

Die Leiter ist besonders chaotisch, da die Schrift nicht monospaced ist.

Abgerollt:

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

Eingabe erfolgt in der Bestellung N, H, W

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

Probieren Sie es online!

Erläuterung

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

-1 Byte danke an 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}

Probieren Sie es online!

Anonyme Funktion; Gibt das Ergebnis als Matrix zurück.

Dank dieser Word Grids-Frage habe ich viel mehr als sonst über Matrizen nachgedacht. Ich habe festgestellt, dass sich die Sprossen in den Matrixzeilen befinden, die ein Vielfaches der Stufenhöhe sind H(R ist 1-indiziert), und dass die Schienen die erste und die letzte Spalte sind 1und W. Also erstelle ich eine Matrix aus zufälligen ASCII-Zeichen, ersetze die Buchstaben, die diesen Kriterien nicht entsprechen, durch Leerzeichen und gebe die Matrix zurück. TIO Link druckt es schön aus.

Neal Fultz schlug eine andere Indizierung für die Leerzeichen vor [-H*(1:N),3:W-1], die alle Zeichen mit Ausnahme derjenigen in Zeilen mit Vielfachen von H: -H*(1:N)und nicht am Rand 3:W-1<==> ersetzt 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")}

Probieren Sie es online!

Eine Verbesserung gegenüber dem ursprünglichen matrixbasierten Ansatz, mit dem ich begonnen habe; Es ist der gleiche Algorithmus, aber die forSchleifen sind kürzer als das Erstellen und Drucken einer Matrix (aber nicht, wenn ich sie nicht drucke!)

Perl 5 , 81 Bytes

80 Byte Code + 1 für -p.

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

Probieren Sie es online!

Kohle , 34 32 Bytes

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

Probieren Sie es online! Nimmt Eingaben in der Reihenfolge N, H, W vor. Ausführliche Näherung ( Plus(InputNumber(), 1)wird derzeit bei TIO unterbrochen). Erläuterung:

Ｅ…¹×⁺¹ＮＮ

Karte über den Bereich 1..H*(N+1). Dies bedeutet, dass die Sprossen erscheinen, wenn iein Vielfaches von H.

⪫

Verbinden Sie das Ergebnis von:

ＥＩζ

Abbildung über den impliziten Bereich 0..W:

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

Wenn die Spalte nicht 0oder W-1und die Zeile kein Vielfaches von Hist, wird ein Leerzeichen ausgegeben.

§⮌γ‽⁹⁴

Nehmen Sie andernfalls die vordefinierte ASCII-Zeichenvariable, kehren Sie sie um (setzen Sie das Leerzeichen an die 94. Stelle) und drucken Sie ein zufälliges Zeichen aus der jetzt ersten 94. (Weil Slicesaugt)

ω

Verbinden Sie mit der leeren Zeichenfolge. Das Endergebnis wird implizit gedruckt.

C (GCC) , 141 131 114 109 107 Bytes

Sollte in der Lage sein, dies ein bisschen herunter zu spielen ...

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

Probieren Sie es 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}

Probieren Sie es online!

Nimmt (h, n, w) als Argumente. Gibt eine Liste von Zeichenfolgen zurück.

Erläuterung:

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

Probieren Sie es online!

Wir bauen eine Leiter, der nur aus #erstem ( Beispiel ), dann die Schleife |%{...}über jedes Zeichen und ifseinen -eqUAL zu 35, haben wir ein neues ausziehbares RandomZeichen aus dem entsprechenden Bereich. Andernfalls geben wir aus (dh entweder ein Leerzeichen oder eine neue Zeile).

JavaScript (ES6), 117 115 Byte

Eine rekursive Funktion, die die Ausgabe zeichenweise aufbaut.

"Schau, Ma, kein Zeilenvorschub!"

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

Probieren Sie es online!

Gespeicherte Bytes dank ovs!

Pyth, 33 Bytes

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

Probieren Sie es online aus: Demonstration

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*

Probieren Sie es online!

SOGL V0.12 , 32 31 Bytes

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

Probieren Sie es hier aus!

Eingabe in der Reihenfolge N, W, H.

Erläuterung:

 ~Δ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 ohne die zufälligen Zeichen: /

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

Probieren Sie es 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}

Probieren Sie es online!

9 Bytes dank Laikoni gespart

21 Bytes dank wchargin eingespart

Sollte golffähig sein ( b$(s w)<$[2..h]und b$((s w)<$[2..h])++[r w]). Ich fühle mich mit IO und Golf nicht wohl.

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

Erstellt die Leiter aus #Zeichen und ersetzt jedes durch ein zufälliges ASCII-Zeichen.

Testschnipsel

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

Leider schlug Arnauld mich zu einer ähnlichen, aber kürzeren Lösung . Durch die Kombination unserer beiden Lösungen können dies 113 Byte sein

Beinhaltet einen nachgestellten Zeilenumbruch.

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

Versuch es

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

Übernimmt die Eingabe in der Reihenfolge H,W,N.

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

Versuch es

QBIC , 76 Bytes

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

Erläuterung

[                       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

Probelauf

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

MATL , 63 50 Bytes

-13 Bytes dank Luis Mendo

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

Probieren Sie es online!

Ich bin noch neu im Golfspielen in MATL (und ich bin in MATLAB nicht besonders gut), daher weiß ich, dass dies wahrscheinlich nicht annähernd optimal ist. Trinkgelder sind willkommen. Nimmt die Eingabe in der angegebenen Reihenfolge vor N,H,W.

Auf geht'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.

Wir haben jetzt eine Matrix von zufälligen Zeichen.

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

Jetzt gibt es auch eine logische Matrix für die Schienen.

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

Jetzt haben wir 3 Matrizen auf dem Stapel:

• Oben: 0 für Nicht-Strompfad, sonst 1
• Mitte: 0 für Nichtschiene, 1 sonst
• Unten: zufällige Zeichen, -20

Also machen wir folgendes:

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

Weniger Golf-Testskript:

$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

Ausgabe:

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

BEARBEITEN: Hoppla, ich dachte, dies sei eine neue Herausforderung, da kürzlich ein Tippfehler behoben wurde. Ich lasse das aber immer noch offen, weil es noch keine Ruby-Antwort darauf gibt.

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

Probieren Sie es online!