Maintenant que d'autres utilisateurs ont aidé Trump à construire le mur , il est temps pour vous de l'escalader.

Il s'agit d'un défi d'art ascii où vous devez créer un mur d'escalade avec des prises placées au hasard.

Un mur d'escalade est composé de panneaux ayant chacun entre 3 et 10 prises et 5 panneaux de haut. Chaque panneau a 4 caractères de haut et 10 caractères de diamètre

Nous utilisons |pour représenter le côté du mur (l'arête) et a -pour représenter les bords des panneaux. Les coins des panneaux sont représentés par +et les prises sont représentées par o.

Enfin, le mur doit avoir America!en haut et Mexicoen bas.

Votre programme ne doit prendre aucune entrée sauf si une entrée est requise pour s'exécuter et doit produire quelque chose qui ressemble à ce qui suit

Ceci est un exemple de sortie:

  America!
+----------+
|  o       |
|    o o   |
| o    o   |
|  o    o  |
+----------+
|  o       |
|    o o   |
| o    o   |
|  o    o  |
+----------+
|  o       |
|    o o   |
| o    o   |
|  o    o  |
+----------+
|  o       |
|    o o   |
| o    o   |
|  o    o  |
+----------+
|  o       |
|    o o   |
| o    o   |
|  o    o  |
+----------+
   Mexico

Cela peut être présenté de manière confuse, il est donc structuré plus clairement ci-dessous

Contribution

Zilcho. Vous ne devez prendre aucune entrée absolument.

Production

Un mur d'escalade ascii-art composé de 5 panneaux, chacun de 6 lignes par 12 colonnes avec America!centré en haut et Mexicocentré en bas. Chaque panneau a un modèle identique qui est généré de manière aléatoire par le programme. Le modèle de panneau se compose d'un nombre aléatoire de prises réparties au hasard, entre 3 et 10.

Règles

• Aucune entrée autorisée
• Je dirais "pas de builtins" mais si votre langue a un builtin pour cela, je l'accepterai automatiquement comme gagnant.
• C'est le code-golf donc le code le plus court (en octets) gagne.
• La sortie sans attente doit être exactement la même que ci-dessus, à nouveau sans attente.
• Aléatoire est l'aléatoire défini ici

Gelée , 65 57 octets

Première utilisation toujours du nouveau-fangled ⁽, un littéral chaîne entière de deux points de code ( ⁽¥0= 2049)

⁽¥0ṃ⁾+-W
“K2X)»Ṅø40RẊ<8X+3¤s⁵ị⁾o j@€⁾||Yṭ¢µṄ€5¡Ṗ;⁷“Ç€:;#»

Programme complet ne prenant aucune entrée et imprimant le mur.

Essayez-le en ligne!

Comment?

⁽¥0ṃ⁾+-W - Link 1, panel separator: no arguments
⁽¥0      - literal 2049
    ⁾+-  - literal "+-"
   ṃ     - convert 2049 to base "+-" as if they were [1,0]
       W - wrap in a list   -> ["+----------+"]

“K2X)»Ṅø40RẊ<8X+3¤s⁵ị⁾o j@€⁾||Yṭ¢µṄ€5¡Ṗ;⁷“Ç€:;#» - Main link: no arguments
“K2X)»                                           - "  America!"
      Ṅ                                          - print with line feed
       ø                                         - niladic chain separation
        40                                       - literal 40
          R                                      - range -> [1,2,...,40]
           Ẋ                                     - random shuffle
                 ¤                               - nilad and link(s) as a nilad:
             8X                                  -   random integer between 1 and 8
                3                                -   literal 3
               +                                 -   add
            <                                    - less than? (vectorises)
                   ⁵                             - literal 10
                  s                              - split into chunks of length 10
                     ⁾o <-- a space              - literal "o "
                    ị                            - index into
                           ⁾||                   - literal "||"
                        j@€                      - join with reversed @rguments
                              Y                  - join with line feeds
                                ¢                - call last link (1) as a nilad
                               ṭ                 - tack left to right
                                 µ               - call that p... (monadic chain separation)
                                    5¡           - repeat five times:
                                   €             -   for €ach (separator & panel)
                                  Ṅ              -     print with trailing line feed(separator and panel):
                                      Ṗ          - pop (just the separator now)
                                        ⁷        - literal line feed
                                       ;         - concatenate
                                                 - unused value printed
                                         “Ç€:;#» - "   Mexico"
                                                 - implicit print

PHP, 138 octets

<?=($p=str_pad)("  America!",349,strtr("
+----------+
|0|
|1|
|2|
|3|",str_split(str_shuffle($p($p(o,rand(3,10),o),40)),10)))."   Mexico";

Essayez-le en ligne!

Étendu

<?=($p=str_pad)("  America!",349, 
#fill the string till a length of 349 with
strtr("
+----------+
|0|
|1|
|2|
|3|",
# before replace the digits with strings in the array
str_split(str_shuffle($p($p(o,rand(3,10),o),40)),10))) 
# make a string with o length 3- 10 fill it with spaces to length 40
# shuffle the resulting string and split it into a array of strings with length 10
."   Mexico"; # add the end

JavaScript (ES6), 194 160 octets

(h=0,g=p=>h>2?p:g(p.replace(/ /g,_=>" o"[(h+=s=Math.random()>.8)<11&s])))=>`  America!
${t=`+----------+
`}${g(`|          |
`.repeat(4)+t).repeat(5)}   Mexico`

Essayez-le

Le motif des prises changera toutes les 2 secondes dans l'extrait ci-dessous.

f=
(h=0,g=p=>h>2?p:g(p.replace(/ /g,_=>" o"[(h+=s=Math.random()>.8)<11&s])))=>`  America!
${t=`+----------+
`}${g(`|          |
`.repeat(4)+t).repeat(5)}   Mexico`
o.innerText=f()
setInterval("o.innerText=f()",2e3)

<pre id=o>

Explication

• Nous créons une fonction anonyme qui, bien qu'elle ne prenne aucune entrée, a 2 paramètres avec des valeurs par défaut:
  • h, qui reçoit une valeur initiale de 0; cela gardera le nombre de mises en attente sur le panneau lorsque nous allons les ajouter.
  • g, qui est une fonction récursive que nous utiliserons pour créer le motif aléatoire de prises sur le panneau. Nous y reviendrons dans un instant.
• Dans le corps de la fonction principale, nous générons un littéral de modèle, en commençant par America!\n.
• Nous créons ensuite le diviseur de panneaux ( +----------+\n) et l'affectons à la variable t, en l'ajoutant à la sortie du processus.
• Ensuite, nous créons une seule ligne du panneau ( | |\n), la répétons 4 fois et ajoutons t.
• Nous appelons g, en passant la chaîne de l'étape ci-dessus comme argument, via le paramètre p.
• Maintenant, pour le motif de maintien. Dans g:
  • Nous vérifions si h>2(c.-à-d. Avons-nous 3 prises ou plus).
  • Si c'est le cas, nous renvoyons la chaîne p.
  • Sinon, nous appelons à gnouveau, cette fois en passant une copie modifiée de pcomme argument.
  • La copie modifiée de pcontient la replaceméthode utilisée, en remplaçant tous les <space>caractères par un <space>ou un oen référençant l'index des caractères (0 ou 1) de la chaîne <space>o.
  • Nous déterminons l'indice de caractère par
    1. Appel Math.random(), qui renvoie un nombre décimal compris entre 0 et 1, exclusif.
    2. Vérifier si cela est supérieur à .8. Étant donné qu'il y a 40 espaces dans le panneau et qu'il n'y a qu'un maximum de 10 prises, cela améliore la répartition des prises à travers le panneau ( .75serait plus précis, mais, espérons-le, vous me permettrez la concession pour le bien de enregistrer un octet!).
    3. Le booléen de cette vérification est affecté à la variable s.
    4. sest contraint à un entier (0 ou 1) et ajouté à h.
    5. Nous vérifions s'il hest maintenant inférieur à 11 (c.-à-d. Avons-nous actuellement moins de 10 prises) et si sc'était vrai.
    6. Ce booléen est à son tour contraint à un entier, ce qui nous donne un index dans la chaîne.
• Retour à notre sortie! Nous répétons la chaîne retournée g5 fois.
• Et puis ajoutez simplement Mexicoà la fin de la chaîne pour terminer les choses. Phew!

Alternative

Et, tout simplement parce que je pensais que cela aurait fait un bon ajout au défi: pour seulement 12 octets supplémentaires, nous pouvons avoir un modèle unique de prises sur chaque panneau, au lieu d'être tous identiques.

(g=(p=`|          |
`.repeat(4)+t,h=0)=>h>2?p:g(p.replace(/ /g,_=>" o"[(h+=s=Math.random()>.8)<11&s]),h))=>`  America!
${t=`+----------+
`}${g()+g()+g()+g()+g()}    Mexico`

Essayez-le

Encore une fois, les motifs des prises changeront toutes les 2 secondes.

f=
(g=(p=`|          |
`.repeat(4)+t,h=0)=>h>2?p:g(p.replace(/ /g,_=>" o"[(h+=s=Math.random()>.8)<11&s]),h))=>`  America!
${t=`+----------+
`}${g()+g()+g()+g()+g()}    Mexico`
o.innerText=f()
setInterval("o.innerText=f()",2e3)

<pre id=o>

Pyth - 58 57 octets, peut-être 47

Ks(b\+*\-T\+*+++b\|*dT\|4)J<.SxdmdK+3O8+*s.e?/Jk\obK5<K13

Essayez-le

Explication de l'ancienne solution (je mettrai à jour quand j'aurai le temps):

J+++b\+*\-T\+K+J*+++b\|*dT\|4=Y<.SxdmdK+3O8+*s.e?/Yk\obK5J
J+++b\+*\-T\+                                                Create the +----------+, and store as J
             K+J*+++b\|*dT\|4                                Create a full panel (minus bottom border, and without holes), store as K
                                  xdmdK                      Get indices of spaces
                                .S                           Create random permutation of these indices
                               <       +3O8                  Get first several indices (a random number from 3 to 10)
                                             s.e?/Yk\obK     Replace space with 'o' at these indices
                                           +*           5J   Create 5 copies, and add bottom border

Je pense que je peux obtenir 47 tout en suivant techniquement les règles:

JhO2Ks(b\+*\-T\+*+++b\|.S+*\oJ*d-TJ\|4)+*K5<K13

Ici, le nombre de trous est toujours choisi au hasard (dans l'ensemble {4,8}) et la configuration de ces trous est choisie au hasard (dans l'ensemble des configurations où chaque ligne est identique)

Essayez-le

Mathematica, 201 octets

c=Column;s=RandomSample[Tuples[{" ",o," "," "},10],4];t="+----------+";w=c[{t,c[Row/@Table[AppendTo[s[[i]],"|"];PrependTo[s[[i]],"|"],{i,Length@s}]]}];c[Flatten@{"  America!",Table[w,5],t,"   Mexico"}]

Powershell (255 octets)

echo "  America!"
for($l=0;$l-lt4;$l++){$a=," "*12;$a[0]="|";$a[11]="|";$i=get-random -Max 10 -Min 6;$j=get-random -Max 5 -Min 1;$a[$i]=$a[$j]="o";$b+=($a-join"")}
for($k=0;$k-lt5;$k++){echo +----------+($b-join"`n")} 
echo +----------+`n"   Mexico" 

Python 2 , 259 224 221 218 octets

from random import*
b=[' ']*40
for x in sample(range(40),randint(3,10)):b[x]='o'
a=["+"+"-"*10+"+"]+['|'+''.join(o)+'|'for o in[b[x*10:x*10+10]for x in 0,1,2,3]] 
print'\n'.join(['  America!']+a*5+[a[0]]+['   Mexico'])

Essayez-le sur repl.it

-35 y compris quelques indices de @ Satan'sSon - merci!

-3 avec merci à @Wondercricket

Python 2, 197 octets

from random import*
n=randint(3,10)
s=list('o'*n+' '*(40-n))
shuffle(s)
t=10
S='+'+'-'*t+'+'
print'\n'.join(['  America!']+([S]+['|'+''.join(s[x:x+t])+'|'for x in range(0,40,t)])*5+[S,'   Mexico'])