Desafio com tema do Dia da Independência Especial (EUA) para você hoje. Você deve escrever um programa que imprima essa representação artística da bandeira americana.

0
|---------------------------------------------------------
| *   *   *   *   *   * #################################|
|   *   *   *   *   *                                    |
| *   *   *   *   *   *                                  |
|   *   *   *   *   *   #################################|
| *   *   *   *   *   *                                  |
|   *   *   *   *   *                                    |
| *   *   *   *   *   * #################################|
|   *   *   *   *   *                                    |
| *   *   *   *   *   *                                  |
|########################################################|
|                                                        |
|                                                        |
|########################################################|
|                                                        |
|                                                        |
|########################################################|
|                                                        |
|                                                        |
|########################################################|
|---------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|

Espaços à direita em cada linha, bem como uma nova linha à direita, são permitidos.

Observe que essa não é a aparência da bandeira, mas é a mais próxima que eu poderia chegar com o ASCII.

Como de costume, este é um código de golfe, pelo que as brechas padrão se aplicam e a resposta mais curta em bytes ganha!

CJam, 184 120 109 101 76 74 69 67 64 62 58 bytes

0'-57*"  #"56f*'|f+7*2>" *  "50*22/W<Sf+..e&~J$]N'|+a37*.+

Experimente on-line no intérprete CJam .

Idéia

A parte mais interessante da bandeira é o padrão de estrelas e listras.

Se repetirmos dois espaços e um sinal numérico 56 vezes e anexarmos uma barra vertical a cada um, obteremos

                                                         |
                                                         |
#########################################################|

Repetindo esse padrão 7 vezes e descartando as duas primeiras linhas, obtemos as faixas:

#########################################################|
                                                         |
                                                         |
#########################################################|
                                                         |
                                                         |
#########################################################|
                                                         |
                                                         |
#########################################################|
                                                         |
                                                         |
#########################################################|
                                                         |
                                                         |
#########################################################|
                                                         |
                                                         |
#########################################################|

Agora, se repetirmos a sequência " * "50 vezes e dividirmos o resultado em pedaços de comprimento 22, obteremos as estrelas:

 *   *   *   *   *   *
   *   *   *   *   *  
 *   *   *   *   *   *
   *   *   *   *   *  
 *   *   *   *   *   *
   *   *   *   *   *  
 *   *   *   *   *   *
   *   *   *   *   *  
 *   *   *   *   *   *
   

O espaço em branco está um pouco fora, mas podemos consertar isso eliminando o último pedaço e anexando um espaço aos restantes.

Agora, se sobrepormos listras e estrelas, obtemos

 *   *   *   *   *   * #################################|
   *   *   *   *   *                                    |
 *   *   *   *   *   *                                  |
   *   *   *   *   *   #################################|
 *   *   *   *   *   *                                  |
   *   *   *   *   *                                    |
 *   *   *   *   *   * #################################|
   *   *   *   *   *                                    |
 *   *   *   *   *   *                                  |
########################################################|
                                                        |
                                                        |
########################################################|
                                                        |
                                                        |
########################################################|
                                                        |
                                                        |
########################################################|

Tudo o que resta a fazer é adicionar duas linhas de 57 traços, adicionar uma coluna de 37 barras verticais e colocar a cereja no topo.

Código

0         e# Push a zero.
'-57*     e# Push a string of 57 dashes.
"  #"56f* e# Repeat each character in the string 56 times.
'|f+      e# Append a vertical bar to each resulting string.
7*        e# Repeat the resulting array of strings 7 times.
2>        e# Discard the first two strings.
" *  "50* e# Repeat the string 50 times.
22/       e# Split the result into chunks of length 22.
W<        e# Discard the last, partial chunk.
Sf*       e# Append a space to each chunk.
..e&      e# Twofold vectorized logical AND.
          e# Since all characters in the strings are truthy, this always selects
          e# the second character, painting the stars over the stripes.
~         e# Dump all resulting strings on the stack.
J$        e# Copy the string of dashes.

]         e# Wrap the entire stack in an array.
N'|+a37*  e# Repeat ["\n|"] 37 times.
.+        e# Perform vectorized concatenation.

Python 2, 113 bytes

for i in range(38):print i and"|"+["-"*57,(" *  "*7)[i%2*2:][:(i<11)*23].ljust(56,"  #"[i%3])+"|"][1<i<21]*(i<22)

Corte de cordas e módulo verifica em abundância.

Brainf ** k, 3355 3113 1598 1178 782 bytes

Qual é esse idioma?

Aqui está a versão otimizada para mãos, com 28 loops. Acho que levei isso o mais longe que puder.

Aqui está a corrida em ideone.com :

+++[>++++<-]>[>+++>+++>+++>++++++++++>+>++++<<<<<<-]>++++++>---->->>>.<--.
<++++.>>---.>+++++++[<........>-]<<.
<.<<<<+++++[>>.<.>..<<-]>>.<.>.<<++++[>>>........<<<-]>>>.>.>.
<.<<<<+++++[>>...<.<-]+++++[>>.......<<-]>>.>>.>.
<.<<<<++++++[>>.<.>..<<-]++++[>>........<<-]>>>>.>.
<.<<...<<+++++[>.>...<<-]++++[>>>........<<<-]>>>.>.>.
<.<<<<++++++[>>.<.>..<<-]++++[>>........<<-]>>>>.>.
<.<<<<+++++[>>...<.<-]+++++[>>.......<<-]>>.>>.>.
<.<<<<+++++[>>.<.>..<<-]>>.<.>.<<++++[>>>........<<<-]>>>.>.>.
<.<<<<+++++[>>...<.<-]+++++[>>.......<<-]>>.>>.>.
<.<<<<++++++[>>.<.>..<<-]++++[>>........<<-]>>>>.>.
>>>+++[<<<
<.>>>+++++++[<<<<........>>>>-]<<<.>.
>>++[<<
<.<<<<+++++++[>>........<<-]>>>>.>.
>>-]<<
>>>-]<<<
<.>>>+++++++[<<<<........>>>>-]<<<.>.
<.>>.>+++++++[<........>-]<<.
>>++++++++[<<<.>.<.>.>>-]

Como é que isso funciona?

 1: +++[>++++<-]>[>+++>+++>+++>++++++++++>+>++++<<<<<<-]>++++++>---->->>>.<--.
 2: <++++.>>---.>+++++++[<........>-]<<.
 3: <.<<<<+++++[>>.<.>..<<-]>>.<.>.<<++++[>>>........<<<-]>>>.>.>.
 4: <.<<<<+++++[>>...<.<-]+++++[>>.......<<-]>>.>>.>.
 5: <.<<<<++++++[>>.<.>..<<-]++++[>>........<<-]>>>>.>.
 6: <.<<...<<+++++[>.>...<<-]++++[>>>........<<<-]>>>.>.>.
 7: <.<<<<++++++[>>.<.>..<<-]++++[>>........<<-]>>>>.>.
 8: <.<<<<+++++[>>...<.<-]+++++[>>.......<<-]>>.>>.>.
 9: <.<<<<+++++[>>.<.>..<<-]>>.<.>.<<++++[>>>........<<<-]>>>.>.>.
10: <.<<<<+++++[>>...<.<-]+++++[>>.......<<-]>>.>>.>.
11: <.<<<<++++++[>>.<.>..<<-]++++[>>........<<-]>>>>.>.
12: >>>+++[<<<
13: <.>>>+++++++[<<<<........>>>>-]<<<.>.
14: >>++[<<
15: <.<<<<+++++++[>>........<<-]>>>>.>.
16: >>-]<<
17: >>>-]<<<
18: <.>>>+++++++[<<<<........>>>>-]<<<.>.
19: <.>>.>+++++++[<........>-]<<.
20: >>++++++++[<<<.>.<.>.>>-]

Este programa usa 10 locais de memória:

0: loop counter #1
1: loop counter #2
2: "*"  ASCII 42
3: spc  ASCII 32
4: "#"  ASCII 35
5: "|"  ASCII 124
6: "\n" ASCII 10
7: "0"  ASCII 48, "-"  ASCII 45
8: loop counter #3
9: loop counter #4

Linha 1

• Essa linha configura os caracteres ASCII nos registros 2 a 7 (principalmente). Alguns ajustes são feitos mais tarde.
• Este código primeiros coloca em 3 0 registo, e, em seguida, circula 3 vezes incrementando registo 1 quatro vezes cada ciclo: +++[>++++<-]. O resultado final é que o registro 0 é 0 e o registro 1 é 12.
• O 12 é usado como contador de loop para o próximo loop. Por 12 vezes no loop, os registradores 2, 3 e 4 são incrementados 3 vezes, o registrador 5 é incrementado 10 vezes, o registrador 6 é incrementado 1 vez e o registrador 7 é incrementado 4 vezes. No final desse loop, eles contêm: R2 (36), R3 (36), R4 (36), R5 (120), R6 (12), R7 (48). Depois que o registro de loop 2 é incrementado 6 vezes, o registro 3 é decrementado 4 vezes e o registro 4 é decrementado uma vez. Neste ponto, os valores são: R2 (42), R3 (32), R4 (35), R5 (120), R6 (12), R7 (48). Todos os registros, exceto os 5 e 6, contêm seus valores ASCII iniciais.
• O próximo registro 7 é emitido, o "0"no topo da bandeira!
• O próximo registro 6 é decrementado duas vezes para 10 (nova linha ASCII) e a saída. Feito com a primeira linha da bandeira!

Linha 2

• Primeiro, ele incrementa o registro 5 por 4, o que o torna "|"(ASCII 124) e o gera.
• Em seguida, ele diminui o registro 7, alterando-o três de "0"(ASCII 48) para "-"(ASCII 45) e o produz.
• Em seguida, coloca 7 no contador de loop 3 (registro 8) e executa um loop 7 vezes, escrevendo 8 traços de cada vez, totalizando 7 * 8 = 56 traços.
• Finalmente, termina com a saída de uma nova linha.

Linha 3

• Esta linha contém dois loops.
• O primeiro loop escreve " * "5 vezes.
• Então " * "está escrito
• O segundo loop executa um loop 4 vezes, escrevendo 8, "#"totalizando 32.
• Então "#", "|"e "\n"são escritos.

Linhas 4 - 11

• Essas linhas usam a mesma técnica da linha 3 para escrever as estrelas e listras da bandeira.

Linha 12

• Essa linha inicia um loop que é executado 3 vezes.
• O loop termina na linha 17.

Linha 13

• Escreve uma faixa que atravessa a bandeira.
• Usa um loop que é executado 7 vezes, escrevendo "#"8 vezes cada vez no loop.

Linha 14

• O início de um loop que é executado 2 vezes.

Linha 15

• Escreve uma faixa que atravessa a bandeira.
• Usa um loop que é executado 7 vezes, escrevendo " "8 vezes cada vez no loop.

Linha 16

• Fim do loop interno iniciado na linha 14.

Linha 17

• Fim do loop externo iniciado na linha 13.

Linha 18

• Desenha a faixa inferior da bandeira.

Linha 19

• Desenha a borda inferior da bandeira.

Linha 20

• Desenha o mastro da bandeira.
• Loops 8 vezes, escrita "|"e nova linha duas vezes ao longo do loop.

/// : 225 caracteres

/D/ddd//d/--------//H/hhh//h/########//S/sss//s/        //A/aaaaa//a/ *  //b/|HHh|
|SSs|
|SSs|
//p/|
|
|
|
/0
|DDd-
|A * Hh#|
|  A Ss |
|A * Ss |
|  A Hh#|
|A * Ss |
|  A Ss |
|A * Hh#|
|  A Ss |
|A * Ss |
bbb|HHh|
|DDd-
pppp

JavaScript ( ES6 ), 153 156

Usando a sequência de modelos, há 1 nova linha significativa e contada

Teste a execução do snippet abaixo (sendo EcmaScript 6, apenas Firefox)

// TEST - Just for testing purpose,redefine console.log

console.log = (...x) => O.innerHTML += x+'\n'

// SOLUTION

o=[0];for(o[r=1]=o[21]='-'[R='repeat'](57);++r<21;o[r]=" *  "[R](7).substr(r%2*2,r<11&&23)+'  #'[r%3][R](r<11?33:56)+'|')o[37]='';console.log(o.join`
|`)

<pre id=O></pre>

Para ser ainda mais patriótico, aqui está a versão do EcmaScript 5

// TEST - Just for testing purpose,redfine console.log

console.log = function(x){ O.innerHTML += x+'\n' }

// SOLUTION - 175 bytes

for(o=(A=Array)(38),o[0]=0,r=2;r<21;r++)o[r]=A(8)[J='join'](" *  ").substr((r&1)*2,r<11?23:0)+A(r<11?34:57)[J]('  #'[r%3])+'|';
o[1]=o[r]=A(58)[J]('-'),console.log(o[J]('\n|'))

<pre id=O></pre>

Ruby, 104 102 bytes

Usando idéias do Ruby do ManAtWork, responda com permissão.

puts 0,s=?|+?-*57,(0..18).map{|i|?|+("#  "[i%3]*(i>8?56:33)).rjust(56," *   *"[i%2*2,4])+?|},s,'|
'*16

Ruby, 127122121 bytes

As cotações foram alteradas para a ?matriz usada em vez de condicional para a cor da faixa. usado condicional em vez de fórmula para o comprimento da faixa.

puts 0,s=?|+?-*57
19.times{|i|puts ?|+("#  "[i%3]*(i>8?56:33)).rjust(56,i%2>0?"   *":" *  ")+?|}
puts s,"|\n"*16

O truque aqui é desenhar as listras (vermelhas / #brancas / space) no comprimento correto e justificá-las à direita, preenchendo com estrelas. Ruby rjustnos permite especificar a string de preenchimento, que alterna entre " * "e " *".

Versão original, 127 bytes

puts 0,s="|"+"-"*57
19.times{|i|puts("|"+((i%3>0?" ":"#")*((i+1)/10*23+33)).rjust(56,i%2>0?"   *":" *  ")+"|")}
puts s,"|\n"*16

SWI-Prolog, 275 bytes

Em um idioma de origem francesa, que é meio adequado

a:-put(48),nl,b,c(0).
b:-z,w(-,57).
c(I):-nl,I=36;J is I+1,(I=19,b,c(J);I>19,z,c(J);I>8,z,(I mod 3=:=0,w(#,56);tab(56)),z,c(J);z,(I mod 2=:=0,tab(1),w('*   ',5),put(42),tab(1);w('   *',5),tab(3)),(0=:=I mod 3,w(#,33);tab(33)),z,c(J)).
z:-put(124).
w(A,B):-writef('%r',[A,B]).

Veja o resultado aqui

C, 235 211 208 205 203 198 197 186 bytes

i;x(){for(puts("0");i<37;i++){char b[58]="";i<21?memset(b,i%20?i%3&1?35:32:45,56),i&&i<10?memcpy(b," *   *   *   *   *   *   "+(i%2?0:2),23):0,b[56]=i%20?124:45:0;printf("|%.57s\n",b);}}

edit: adicionou algumas sugestões de Cool Guy e fez uso de?: para substituir algumas declarações if.

edit: prevenção de estouro removido \ 0 e, em vez disso, usou o limitador de comprimento de string no printf.

editar: reformulou os dois condicionais do memset.

edit: move puts ("0") dentro do cabeçalho for para remover seu ponto e vírgula.

edit: leve refatoração para obter mais 11 bytes.