Un défi sur le thème du Jour de l'Indépendance Spécial (USA) pour vous aujourd'hui. Vous devez écrire un programme qui imprime cette représentation ascii-art du drapeau américain.

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

Les espaces de fin sur chaque ligne, ainsi qu'une nouvelle ligne de fin, sont autorisés.

Notez que ce n'est pas tout à fait à quoi le drapeau devrait ressembler, mais c'est le plus proche que je pourrais obtenir avec ASCII.

Comme d'habitude, il s'agit de code-golf, donc les failles standard s'appliquent et la réponse la plus courte en octets gagne!

CJAM, 184 120 109 101 76 74 69 67 64 62 58 octets

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

Essayez-le en ligne dans l' interpréteur CJam .

Idée

La partie la plus intéressante du drapeau est le motif d'étoiles et de rayures.

Si nous répétons deux espaces et un nombre signe 56 fois et ajoutons une barre verticale à chacun, nous obtenons

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

En répétant ce motif 7 fois et en rejetant les deux premières lignes, nous obtenons les rayures:

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

Maintenant, si nous répétons la chaîne " * "50 fois et divisons le résultat en morceaux de longueur 22, nous obtenons les étoiles:

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

L'espace est un peu décalé, mais nous pouvons résoudre ce problème en éliminant le dernier morceau et en ajoutant un espace aux autres.

Maintenant, si nous superposons des rayures et des étoiles, nous obtenons

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

Il ne reste plus qu'à ajouter deux lignes de 57 tirets, à ajouter une colonne de 37 barres verticales et à placer la cerise sur le dessus.

Code

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 octets

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)

Tranchage de cordes et contrôles modulo à gogo.

Brainf ** k, 3355 3113 1598 1178 782 octets

Quel est ce langage?

Voici la version optimisée à la main avec 28 boucles. Je pense que je suis allé aussi loin que possible.

Voici la course à ideone.com :

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

Comment cela marche-t-il?

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

Ce programme utilise 10 emplacements de mémoire:

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

Ligne 1

• Cette ligne configure les caractères ASCII dans les registres 2 à 7 (principalement). Quelques ajustements sont effectués plus tard.
• Ce code met d' abord dans le registre 3 0 et les boucles puis 3 fois incrémenter le registre 1 quatre fois chaque boucle: +++[>++++<-]. Le résultat final est que le registre 0 est 0 et le registre 1 est 12.
• Le 12 est utilisé comme compteur de boucle pour la boucle suivante. Pendant 12 fois la boucle, les registres 2, 3 et 4 sont incrémentés 3 fois, le registre 5 est incrémenté 10 fois, le registre 6 est incrémenté 1 fois et le registre 7 est incrémenté 4 fois. À la fin de cette boucle, ils contiennent: R2 (36), R3 (36), R4 (36), R5 (120), R6 (12), R7 (48). Après que le registre de boucle 2 a été incrémenté 6 fois, le registre 3 est décrémenté 4 fois et le registre 4 est décrémenté une fois. À ce stade, les valeurs sont: R2 (42), R3 (32), R4 (35), R5 (120), R6 (12), R7 (48). Tous, sauf les registres 5 et 6, contiennent leurs valeurs ASCII initiales.
• Le registre 7 suivant est sorti, le "0"en haut du drapeau!
• Le registre suivant 6 est décrémenté deux fois à 10 (nouvelle ligne ASCII) et sorti. Fait avec la première ligne du drapeau!

Ligne 2

• D'abord, il incrémente le registre 5 par 4, ce qui le rend "|"(ASCII 124) et le sort.
• Ensuite, il décrémente le registre 7 de trois en le changeant de "0"(ASCII 48) en "-"(ASCII 45) et le sort.
• Ensuite, il met 7 dans le compteur de boucle 3 (registre 8) et boucle 7 fois, écrivant 8 tirets à chaque fois pour un total de 7 * 8 = 56 tirets.
• Enfin, il se termine par la sortie d'une nouvelle ligne.

Ligne 3

• Cette ligne contient deux boucles.
• La première boucle écrit " * "5 fois.
• Puis " * "est écrit
• La deuxième boucle boucle 4 fois en écrivant 8 "#"pour un total de 32.
• Ensuite "#", "|"et "\n"sont écrits.

Lignes 4 à 11

• Ces lignes utilisent la même technique que la ligne 3 pour écrire les étoiles et les rayures du drapeau.

Ligne 12

• Cette ligne démarre une boucle qui s'exécute 3 fois.
• La boucle se termine à la ligne 17.

Ligne 13

• Écrit une bande qui traverse le drapeau.
• Utilise une boucle qui s'exécute 7 fois en écrivant "#"8 fois à chaque fois dans la boucle.

Ligne 14

• Le début d'une boucle qui s'exécute 2 fois.

Ligne 15

• Écrit une bande qui traverse le drapeau.
• Utilise une boucle qui s'exécute 7 fois en écrivant " "8 fois à chaque fois dans la boucle.

Ligne 16

• Fin de la boucle intérieure qui a commencé à la ligne 14.

Ligne 17

• Fin de la boucle extérieure qui a commencé à la ligne 13.

Ligne 18

• Dessine la bande inférieure du drapeau.

Ligne 19

• Dessine la bordure inférieure du drapeau.

Ligne 20

• Dessine le mât.
• Boucles 8 fois, écriture "|"et saut de ligne deux fois à chaque fois dans la boucle.

/// : 225 caractères

/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

En utilisant la chaîne de modèle, il y a 1 nouvelle ligne qui est significative et comptée

Testez l'exécution de l'extrait ci-dessous (étant EcmaScript 6, Firefox uniquement)

// 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>

Pour être encore plus patriotique, voici la version 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>

Rubis, 104 102 octets

Utiliser les idées de Ruby de ManAtWork répondre avec permission.

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

Rubis, 127 121 112 octets

Changement des guillemets dans le ?tableau utilisé au lieu de conditionnel pour la couleur de la bande. utilisé conditionnel au lieu de formule pour la longueur de bande.

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

L'astuce ici est de dessiner les rayures (à la fois rouge / #et blanc / space) à la bonne longueur, puis de les justifier à droite, en remplissant d'étoiles. Ruby's rjustnous permet de spécifier la chaîne de remplissage, qui alterne entre " * "et " *".

Version originale, 127 octets

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 octets

Dans une langue d'origine française, ce qui est un peu approprié

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

Voir le résultat ici

C, 235 211 208 205 203 198 197 197 186 octets

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: ajout de quelques suggestions de Cool Guy et utilisation de?: pour remplacer certaines instructions if.

edit: suppression de la prévention du débordement \ 0 et utilisation du limiteur de longueur de chaîne dans printf à la place.

edit: retravaillé les deux conditions memset.

edit: déplacé met ("0") à l'intérieur de l'en-tête for pour supprimer son point-virgule.

edit: léger refactoring pour obtenir 11 octets de plus.