Heute steht für Sie eine spezielle Herausforderung zum Thema Unabhängigkeitstag (USA) an . Sie müssen ein Programm schreiben, das diese ASCII-Darstellung der amerikanischen Flagge druckt.

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

Nachgestellte Leerzeichen in jeder Zeile sowie ein nachstehender Zeilenumbruch sind zulässig.

Beachten Sie, dass das Flag nicht ganz so aussehen sollte, aber mit ASCII am ehesten zu erreichen ist.

Wie üblich, ist dieser Code-Golf so Standard Lücken gelten und kürzeste Antwort in Bytes gewinnt!

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*.+

Probieren Sie es online im CJam-Interpreter aus .

Idee

Der interessanteste Teil der Flagge ist das Sternenbanner-Muster.

Wenn wir zwei Leerzeichen und ein Nummernzeichen 56 Mal wiederholen und jeweils einen vertikalen Strich anhängen, erhalten wir

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

Wenn Sie dieses Muster siebenmal wiederholen und die ersten beiden Zeilen verwerfen, erhalten Sie die Streifen:

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

Wenn wir nun die Zeichenfolge " * "50 Mal wiederholen und das Ergebnis in Stücke mit der Länge 22 aufteilen, erhalten wir die Sterne:

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

Das Leerzeichen ist ein wenig veraltet, aber wir können das beheben, indem wir den letzten Block entfernen und an die verbleibenden Leerzeichen ein Leerzeichen anhängen.

Wenn wir nun Streifen und Sterne überlagern, erhalten wir

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

Jetzt müssen Sie nur noch zwei Zeilen mit 57 Strichen hinzufügen, eine Spalte mit 37 vertikalen Balken hinzufügen und die Kirsche darauf setzen.

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

String Slicing und Modulo Checks in Hülle und Fülle.

Brainf ** k, 3355 3113 1598 1178 782 Bytes

Welche Sprache ist das?

Hier ist die handoptimierte Version mit 28 Loops. Ich glaube, ich bin so weit gegangen, wie es gehen wird.

Hier ist der Lauf bei ideone.com :

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

Wie funktioniert das?

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

Dieses Programm verwendet 10 Speicherplätze:

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

Linie 1

• Diese Zeile richtet die ASCII-Zeichen in den Registern 2 bis 7 (meistens) ein. Einige Anpassungen werden später vorgenommen.
• Dieser Code setzt zuerst 3 in Register 0 und schleift dann dreimal inkrementiert Register 1 viermal in jeder Schleife: +++[>++++<-] . Das Endergebnis ist, dass Register 0 0 ist und Register 1 12 ist.
• Die 12 wird als Schleifenzähler für die nächste Schleife verwendet. Während 12 Durchläufen der Schleife werden die Register 2, 3 und 4 dreimal inkrementiert, Register 5 wird zehnmal inkrementiert, Register 6 wird ein Mal inkrementiert und Register 7 wird viermal inkrementiert. Am Ende dieser Schleife enthalten sie: R2 (36), R3 (36), R4 (36), R5 (120), R6 (12), R7 (48). Nachdem das Schleifenregister 2 sechsmal inkrementiert wurde, wird das Register 3 viermal dekrementiert und das Register 4 wird einmal dekrementiert. Zu diesem Zeitpunkt sind die Werte: R2 (42), R3 (32), R4 (35), R5 (120), R6 (12), R7 (48). Alle außer den Registern 5 und 6 enthalten ihre anfänglichen ASCII-Werte.
• Als nächstes wird das Register 7 ausgegeben, das "0"am oberen Rand der Flagge steht!
• Das nächste Register 6 wird zweimal auf 10 (ASCII-Newline) dekrementiert und ausgegeben. Fertig mit der ersten Zeile der Flagge!

Zeile 2

• Zuerst erhöht es das Register 5 um 4, wodurch es entsteht "|" (ASCII 124) und ausgegeben wird.
• Dann dekrementiert es das Register 7 um drei und ändert es von "0"(ASCII 48) in"-" (ASCII 45) und gibt es aus.
• Als nächstes setzt es 7 in den Schleifenzähler 3 (Register 8) und schleift 7 Mal, wobei jedes Mal 8 Striche für insgesamt 7 · 8 = 56 Striche ausgegeben werden.
• Zum Schluss wird eine neue Zeile ausgegeben.

Zeile 3

• Diese Zeile enthält zwei Schleifen.
• Die erste Schleife schreibt " * " 5 mal.
• Dann " * " wird geschrieben
• Die zweite Schleife wiederholt 4-mal das Schreiben von 8 "#" für insgesamt 32.
• Dann "#", "|"und "\n"sind geschrieben.

Zeilen 4 - 11

• Diese Linien verwenden die gleiche Technik wie Linie 3, um die Sterne und Streifen der Flagge zu schreiben.

Zeile 12

• Diese Zeile startet eine Schleife, die dreimal ausgeführt wird.
• Die Schleife endet in Zeile 17.

Zeile 13

• Schreibt einen Streifen, der über die Flagge geht.
• Verwendet eine Schleife, die "#"siebenmal ausgeführt wird und jedes Mal achtmal durch die Schleife schreibt .

Zeile 14

• Der Beginn einer Schleife, die zweimal ausgeführt wird.

Zeile 15

• Schreibt einen Streifen, der über die Flagge geht.
• Verwendet eine Schleife, die " "siebenmal ausgeführt wird und jedes Mal achtmal durch die Schleife schreibt .

Zeile 16

• Ende der inneren Schleife, die in Zeile 14 begonnen hat.

Linie 17

• Ende der äußeren Schleife, die in Zeile 13 begonnen hat.

Linie 18

• Zeichnet den unteren Streifen der Flagge.

Zeile 19

• Zeichnet den unteren Rand der Flagge.

Zeile 20

• Zeichnet den Fahnenmast.
• Schleifen 8 Mal, Schreiben "|"und Zeilenumbruch zweimal durch die Schleife.

/// : 225 Zeichen

/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

Unter Verwendung der Vorlagenzeichenfolge gibt es 1 Zeilenumbruch, der signifikant ist und gezählt wird

Teste das folgende Snippet (nur in EcmaScript 6, 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>

Um noch patriotischer zu sein, gibt es hier die EcmaScript 5-Version

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

Mit Genehmigung Ideen aus der Ruby-Antwort von ManAtWork verwenden.

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

Ruby, 127 121 112 Bytes

Die Anführungszeichen wurden in ein ?verwendetes Array geändert, anstatt eine Bedingung für die Streifenfarbe zu setzen. wird als Bedingung anstelle der Formel für die Streifenlänge verwendet.

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

Der Trick dabei ist, die Streifen (rot / #und weiß / space) auf die richtige Länge zu zeichnen und sie dann richtig auszurichten und mit Sternen zu füllen. Ruby'srjust können wir die Füllzeichenfolge angeben, die zwischen " * "und wechselt " *".

Originalversion, 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

In einer Sprache französischer Herkunft, die irgendwie passt

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

Sehen Sie das Ergebnis hier

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: hat einige Vorschläge von Cool Guy hinzugefügt und?: verwendet, um einige if-Anweisungen zu ersetzen.

edit: Verhinderung von Überlauf \ 0 entfernt und stattdessen Zeichenkettenlängenbegrenzer in printf verwendet.

Bearbeiten: Beide Memset-Bedingungen wurden überarbeitet.

edit: verschobene Puts ("0") in der for-Kopfzeile, um das Semikolon zu entfernen.

edit: leichtes refactoring um 11 weitere bytes zu bekommen.