Ora che altri utenti hanno aiutato Trump a costruire il muro , è tempo che tu lo scali.

Questa è una sfida di arte ascii in cui è necessario creare una parete da arrampicata con prese posizionate casualmente.

Una parete da arrampicata è composta da pannelli ciascuno dei quali ha tra 3 e 10 prese ed è alto 5 pannelli. Ogni pannello ha una lunghezza di 4 caratteri e 10 caratteri di diametro

Usiamo |per rappresentare il lato del muro (l'arête) e a -per rappresentare i bordi dei pannelli. Gli angoli dei pannelli sono indicati da +e le prese sono mostrate come o.

Infine, il muro deve avere America!in alto e Mexicoin basso.

Il tuo programma non dovrebbe ricevere input a meno che l'input non sia necessario per l'esecuzione e dovrebbe produrre qualcosa di simile al seguente

Questo è un esempio di output:

  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

Questo può essere definito in modo confuso, quindi è strutturato più chiaramente di seguito

Ingresso

Zilcho. Non dovresti prendere assolutamente input.

Produzione

Una parete da arrampicata in arte ascii composta da 5 pannelli, ciascuno 6 linee da 12 colonne con America!centrato nella parte superiore e Mexicocentrato nella parte inferiore. Ogni pannello ha un modello identico che viene generato casualmente dal programma. Il modello del pannello è costituito da un numero casuale casuale di prese, tra 3 e 10.

Regole

• Nessun input consentito
• Direi "no builtin" ma se la tua lingua ha un builtin per questo, lo accetterò automaticamente come vincitore.
• Questo è code-golf quindi vince il codice più breve (in byte).
• L'output senza blocchi deve essere esattamente uguale a quello sopra, sempre senza blocchi.
• Casuale è il casuale definito qui

Gelatina , 65 57 byte

Primo utilizzo assoluto del valore letterale stringa stringa intera⁽ a due punti , new-fangled ( ⁽¥0= 2049)

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

Programma completo senza input e stampa del muro.

Provalo online!

Come?

⁽¥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 byte

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

Provalo online!

allargato

<?=($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 byte

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

Provalo

Lo schema delle prese cambierà ogni 2 secondi nello snippet di seguito.

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>

Spiegazione

• Creiamo una funzione anonima, che, sebbene non richieda alcun input, ha 2 parametri con valori predefiniti:
  • h, a cui viene assegnato un valore iniziale di 0; questo terrà conto del numero di prese sul pannello quando andiamo ad aggiungerle.
  • g, che è una funzione ricorsiva che useremo per creare il modello casuale di prese sul pannello. Torneremo su questo tra poco.
• Nel corpo della funzione principale, abbiamo prodotto un template letterale, a partire da America!\n.
• Quindi creiamo il pannello divisore ( +----------+\n) e lo assegniamo alla variabile t, aggiungendolo all'output nel processo.
• Successivamente, creiamo una singola riga del pannello ( | |\n), la ripetiamo 4 volte e aggiungiamo t.
• Chiamiamo g, passando la stringa dal passaggio precedente come argomento, tramite parametro p.
• Ora, per il modello di attesa. Entro g:
  • Controlliamo per vedere se h>2(cioè, abbiamo 3 o più prese).
  • In tal caso, restituiamo la stringa p.
  • In caso contrario, chiamiamo di gnuovo, questa volta passando una copia modificata di pcome argomento.
  • La copia modificata di pha il replacemetodo usato su di essa, sostituendo tutti i <space>caratteri con a <space>o a ofacendo riferimento all'indice dei caratteri (0 o 1) della stringa <space>o.
  • Determiniamo l'indice dei caratteri per
    1. Chiamata Math.random(), che restituisce un numero decimale compreso tra 0 e 1, esclusivo.
    2. Verifica se è maggiore di .8. Con il loro essere 40 spazi nel pannello e ci sono solo un massimo di 10 prese, farlo migliora la distribuzione delle prese attraverso il pannello ( .75sarebbe più preciso, ma, si spera, mi consentirai la concessione per il bene di salvando un byte!).
    3. Il valore booleano di tale controllo è assegnato alla variabile s.
    4. sè forzato a un numero intero (0 o 1) e aggiunto a h.
    5. Controlliamo se hora è inferiore a 11 (ovvero, al momento abbiamo meno di 10 prese ) e se sera vero.
    6. Questo booleano è a sua volta costretto a un numero intero, dandoci un indice nella stringa.
• Torna alla nostra produzione! Ripetiamo la stringa restituita per g5 volte.
• E poi aggiungi semplicemente Mexicoalla fine della stringa per finire le cose. Accidenti!

Alternativa

E, semplicemente perché pensavo che avrebbe fatto una bella aggiunta alla sfida: per soli 12 byte extra, possiamo avere un modello unico di prese su ciascun pannello, invece che tutte identiche.

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

Provalo

Ancora una volta, i motivi delle prese cambieranno ogni 2 secondi.

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 byte, forse 47

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

Provalo

Spiegazione della vecchia soluzione (aggiornerò quando avrò il tempo):

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

Penso di poter ottenere 47 pur seguendo tecnicamente le regole:

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

Qui, il numero di fori viene ancora scelto in modo casuale (dall'insieme {4,8}) e la configurazione di tali fori viene scelta in modo casuale (dall'insieme di configurazioni in cui ogni riga è identica)

Provalo

Mathematica, 201 byte

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

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 byte

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

Provalo su repl.it

-35 compresi alcuni suggerimenti da @ Satan'sSon - grazie!

-3 grazie a @Wondercricket

Python 2, 197 byte

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