Agora que outros usuários ajudaram Trump a construir o muro , é hora de você escalá-lo.

Esse é um desafio de arte ascii, no qual você precisa gerar uma parede de escalada com porões colocados aleatoriamente.

Uma parede de escalada é composta por painéis, cada um dos quais com 3 a 10 porões e com 5 painéis de altura. Cada painel tem 4 caracteres de altura e 10 caracteres de largura

Usamos |para representar o lado da parede (o arête) e a -para representar as bordas dos painéis. Os cantos dos painéis são mostrados por +e os porões são mostrados como o.

Finalmente, a parede deve ter America!na parte superior e Mexicona parte inferior.

Seu programa não deve receber entrada, a menos que seja necessária a execução e deva produzir algo parecido com o abaixo

Este é um exemplo de saída:

  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

Isso pode ser confundido, por isso é estruturado mais claramente abaixo

Entrada

Zilcho. Você não deve aceitar absolutamente nada.

Resultado

Uma parede de escalada de arte ascii composta por 5 painéis, cada um com 6 linhas por 12 colunas, America!centralizado na parte superior e Mexicocentralizado na parte inferior. Cada painel tem um padrão idêntico que é gerado aleatoriamente pelo programa. O padrão do painel consiste em um número aleatório distribuído aleatoriamente de retenções, entre 3 e 10.

Regras

• Nenhuma entrada permitida
• Eu diria "no builtins", mas se o seu idioma tiver um builtin para isso, eu o aceitarei automaticamente como vencedor.
• Este é o código-golfe, pelo que o código mais curto (em bytes) vence.
• A saída sem retenções deve ser exatamente a mesma que acima, novamente sem retenções.
• Aleatório é o aleatório definido aqui

Geléia , 65 57 bytes

Primeiro uso da literal de sequência inteira com dois pontos de código⁽ , fan-fangled ( ⁽¥0= 2049)

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

Programa completo sem entrada e impressão na parede.

Experimente online!

Quão?

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

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

Experimente online!

Expandido

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

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

Tente

O padrão das retenções mudará a cada 2 segundos no snippet abaixo.

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>

Explicação

• Criamos uma função anônima que, embora não receba nenhuma entrada, possui 2 parâmetros com valores padrão:
  • h, que recebe um valor inicial de 0; isso manterá a contagem do número de retenções no painel quando formos adicioná-las.
  • g, que é uma função recursiva que usaremos para criar o padrão aleatório de retenções no painel. Voltaremos a isso daqui a pouco.
• No corpo da função principal, produzimos um literal de modelo, começando com America!\n.
• Em seguida, criamos o divisor do painel ( +----------+\n) e o atribuímos à variável t, adicionando-o à saída no processo.
• Em seguida, criamos uma única linha do painel ( | |\n), repetimos 4 vezes e anexamos t.
• Chamamos g, passando a string da etapa acima como argumento, via parâmetro p.
• Agora, para o padrão de espera. Dentro de g:
  • Verificamos se h>2(por exemplo, temos 3 ou mais retenções).
  • Nesse caso, retornamos a string p.
  • Caso contrário, chamamos gnovamente, desta vez passando uma cópia modificada de pcomo argumento.
  • A cópia modificada de ptem o replacemétodo usado, substituindo todos os <space>caracteres por um <space>ou um o, referenciando o índice de caracteres (0 ou 1) da sequência <space>o.
  • Determinamos o índice de caracteres por
    1. Chamada Math.random(), que retorna um número decimal entre 0 e 1, exclusivo.
    2. Verificando se isso é maior que .8. Sendo 40 espaços no painel e existindo apenas um máximo de 10 retenções, isso melhora a distribuição das retenções no painel ( .75seria mais preciso, mas espero que você me permita a concessão em nome de salvando um byte!).
    3. O boolean desse cheque é atribuído à variável s.
    4. sé coagido a um número inteiro (0 ou 1) e adicionado a h.
    5. Verificamos se hagora é menor que 11 (ou seja, atualmente temos menos de 10 retenções) e se sera verdade.
    6. Por sua vez, esse booleano é coagido a um número inteiro, fornecendo um índice na string.
• De volta à nossa saída! Repetimos a string retornada g5 vezes.
• E então basta adicionar Mexicono final da string para finalizar as coisas. Ufa!

Alternativo

E, simplesmente porque eu pensei que isso seria uma boa adição ao desafio: por apenas 12 bytes extras, podemos ter um padrão único de retenções em cada painel, em vez de todos serem idênticos.

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

Tente

Mais uma vez, os padrões das retenções mudam a cada 2 segundos.

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 bytes, possivelmente 47

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

Tente

Explicação da solução antiga (atualizarei quando tiver 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

Acho que consigo 47 enquanto ainda tecnicamente segue as regras:

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

Aqui, o número de furos ainda é escolhido aleatoriamente (no conjunto {4,8}) e a configuração desses furos é escolhida aleatoriamente (no conjunto de configurações em que cada linha é idêntica)

Tente

Mathematica, 201 bytes

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

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 bytes

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

Experimente em repl.it

-35 incluindo algumas dicas do @ Satan'sSon - obrigado!

-3 com graças a @Wondercricket

Python 2, 197 bytes

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