Vous ne savez rien Ce que je fais pour "Le chaos est une échelle " est une ligne mémorable de la série télévisée Game of Thrones .

Le but de ce défi est de construire une échelle du chaos, dans l'art ASCII.

Le défi

Contribution

• Largeur de l'échelle, W >= 3(entier)
• Hauteur du pas, H >= 2(entier)
• Nombre de barreaux, N >= 2(entier).

Sortie

Une échelle avec des barreaux horizontaux et des rails verticaux , tous larges d'un caractère. La largeur de l'échelle ( W) inclut les deux rails et la hauteur de marche ( H) inclut le barreau correspondant.

Tous les barreaux, y compris les plus hauts et les plus bas, auront un morceau de rail vertical de longueur H-1directement au-dessus et au-dessous. L'exemple rendra cela plus clair.

Le schéma sera constitué de caractères ASCII imprimables non-d'espaces , c'est-à-dire de la plage comprise entre !(point de code 33) et ~(point de code 126). Les caractères réels seront choisis de manière aléatoire . Étant donné les entrées, chacun des choix aléatoires de caractères doit avoir une probabilité non nulle. Autre que cela, la distribution de probabilité est arbitraire.

Les espaces de début ou de fin , horizontaux ou verticaux, sont autorisés.

Exemple

Étant donné W=5, H=3, N=2, une sortie possible est la suivante.

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

Notez que la hauteur totale est H*(N+1)-1, car il y a des Nbarreaux et N+1des sections verticales.

Règles additionnelles

• Les moyens de saisie et le format sont flexibles comme d’habitude. Par exemple, vous pouvez entrer les trois nombres dans n'importe quel ordre ou un tableau les contenant.

• La sortie peut être via STDOUT ou un argument renvoyé par une fonction. Dans ce cas, il peut s'agir d'une chaîne avec des nouvelles lignes, d'un tableau de caractères 2D ou d'un tableau de chaînes.

• Un programme ou une fonction peut être fourni.

• Les failles standard sont interdites.

• Le code le plus court en octets gagne.

Cas de test

Pour chacun, W, H, Nune sortie possible est affichée.

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 octets

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

Un programme complet prenant les trois arguments W, H, Net d' imprimer le résultat.

Essayez-le en ligne!

Comment?

Construit un masque de tableau en 2D à partir d’un seul réseau et de ses sections verticales ci-dessous, répète N+1fois et supprime le dernier réseau, puis place des caractères aléatoires ou des espaces en fonction de la valeur du masque.

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

Langage de script Operation Flashpoint , 643 624 octets

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}

Ridiculement long car il n'y a aucun moyen de créer les caractères à partir des codes de caractères.

Appeler avec:

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

Sortie:

L'échelle est très chaotique car la police n'est pas à espacement fixe.

Déroulé:

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 octets

Entrée prise dans la commande N, H, W

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

Essayez-le en ligne!

Explication

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

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 octets

-13 octets grâce à Neal Fultz!

-1 octet grâce à 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}

Essayez-le en ligne!

Fonction anonyme; renvoie le résultat sous forme de matrice.

Grâce à cette question de Word Grids , j'ai beaucoup plus pensé aux matrices que d'habitude. J'ai observé que les lignes se trouvaient dans les lignes de la matrice qui étaient un multiple de la hauteur de l'étape H(R est indexé sur 1), et que les rails étaient les première et dernière colonnes, 1et W. Je crée donc une matrice de caractères ASCII aléatoires, remplace les lettres qui ne correspondent pas à ces critères par des espaces et renvoie la matrice. Le lien TIO l’imprime bien.

Neal Fultz a suggéré une indexation différente pour les caractères d'espacement [-H*(1:N),3:W-1], qui remplace tous les caractères à l'exception de ceux en rangées de multiples de H: -H*(1:N)et non sur le bord, 3:W-1<==> 2:(W-1).

R , 121 octets

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

Essayez-le en ligne!

Une amélioration par rapport à l'approche initiale basée sur la matrice avec laquelle j'ai commencé; C'est le même algorithme mais les forboucles sont plus courtes que de construire et d'imprimer une matrice (mais pas si je ne l'imprime pas!)

Perl 5 , 81 octets

Code 80 octets + 1 pour -p.

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

Essayez-le en ligne!

Charbon de bois , 34 32 octets

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

Essayez-le en ligne! Prend les entrées dans l'ordre approximatif N, H, W. Verbose ( Plus(InputNumber(), 1)est actuellement cassé sur TIO). Explication:

Ｅ…¹×⁺¹ＮＮ

Carte sur la plage 1..H*(N+1). Cela signifie que les barreaux apparaissent quand iest un multiple de H.

⪫

Rejoignez le résultat de:

ＥＩζ

mappage sur la plage implicite 0..W:

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

si la colonne n'est pas 0ou W-1et que la ligne n'est pas un multiple de, Hindiquez un espace;

§⮌γ‽⁹⁴

sinon, prenez la variable de caractère ASCII prédéfinie, inversez-la (en plaçant l'espace à la 94e place) et imprimez un caractère aléatoire de ce qui est maintenant le premier 94. (Parce que c'est Slicenul.)

ω

Rejoignez en utilisant la chaîne vide. Le résultat final est imprimé implicitement.

C (gcc) , 141 131 114 109 107 octets

Devrait être capable de jouer au golf un peu ...

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

Essayez-le en ligne!

Perl 6 , 76 73 octets

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

Essayez-le en ligne!

Prend (h, n, w) comme arguments. Retourne une liste de chaînes.

Explication:

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

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

Essayez-le en ligne!

Nous construisons une échelle composée uniquement de #premier ( exemple ), puis nous parcourons |%{...}chaque caractère et, ifcomme d' -eqhabitude 35, nous extrayons un nouveau Randomcaractère de la plage appropriée. Sinon, nous produisons une sortie (c’est-à-dire un espace ou une nouvelle ligne).

JavaScript (ES6), 117 115 octets

Une fonction récursive construisant la sortie caractère par caractère.

"Regardez Ma, pas de saut de ligne littéral!"

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

Démo

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 octets

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*

Essayez-le en ligne!

Octets sauvegardés grâce à ovs!

Pyth, 33 octets

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

Essayez-le en ligne: démonstration

Python 2 , 114 octets

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*

Essayez-le en ligne!

SOGL V0.12 , 32 31 octets

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

Essayez-le ici!

Entrée dans l'ordre N, W, H.

Explication:

 ~Δ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 octets sans les caractères aléatoires: /

Java 8, 203 188 168 133 132 130 130 128 126 octets

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

Essayez-le en ligne!

Haskell , 226 220 211 190 octets

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}

Essayez-le en ligne!

Économisé 9 octets grâce à Laikoni

21 octets sauvés grâce à wchargin

Devrait être golfable ( b$(s w)<$[2..h]et b$((s w)<$[2..h])++[r w]). Je ne me sens pas à l'aise avec IO et le golf.

JavaScript (ES6), 144 octets

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

Crée l’échelle de #caractères, puis les remplace par un caractère ASCII aléatoire.

Test Snippet

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 octets

Malheureusement, alors que j'étais en train de jouer au golf, Arnauld m'a battu pour une solution similaire mais plus courte . En combinant nos 2 solutions, cela peut être 113 octets

Inclut un retour à la ligne.

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

L'essayer

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 octets

Prend une entrée dans la commande H,W,N.

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

L'essayer

QBIC , 76 octets

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

Explication

[                       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

Échantillon échantillon

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

MATL , 63 50 octets

-13 octets grâce à Luis Mendo

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

Essayez-le en ligne!

Je suis encore nouveau au golf en MATL (et je ne suis pas très bon chez MATLAB d'ailleurs), donc je sais que cela n’est probablement pas optimal. Les pourboires sont les bienvenus. Prend les entrées dans l'ordre N,H,W.

Et c'est parti:

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.

Nous avons maintenant une matrice de caractères aléatoires.

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

Maintenant, il y a aussi une matrice logique pour les rails.

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

Maintenant nous avons 3 matrices sur la pile:

• Top: 0 pour les autres, 1 sinon
• Au milieu: 0 pour les chemins de fer, 1 sinon
• En bas: caractères aléatoires, -20

Nous faisons donc ce qui suit:

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

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

Script de test moins joué:

$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

Sortie:

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 octets

EDIT: Oups, je pensais que c'était un nouveau défi à cause de la récente modification pour corriger une faute de frappe. Je laisse encore ça parce qu'il n'y a pas encore de réponse pour Ruby.

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

Essayez-le en ligne!