Drucken Sie die amerikanische Flagge!

29

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!

code-golf  ascii-art  kolmogorov-complexity 
— DJMcMayhem
quelle
Darf Leerzeichen nachgestellt werden?
— Dennis
@ Tennis, solange es nicht übertrieben ist, verstehe ich nicht, warum nicht. Eine nachgestellte Zeile ist also in Ordnung.
— DJMcMayhem
9
Ich würde dies zu einem Pop-Wettbewerb machen und sehen, wer die realistischste Flagge druckt.
— Hosch250,
7
@ Hosch250 Das würde als "Kunstwettbewerb"
— enden
1
@steveverrill Ja, aber wir könnten vielleicht eine Flagge zeichnen, die im Wind weht.
— Hosch250,

Antworten:

21

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.
— Dennis
quelle
13
Für einen sehr kurzen, magischen Moment habe ich dich geschlagen
— edc65
2
Es kommt nicht jeden Tag vor, dass jemand ein 120 Byte langes CJam-Programm schreibt.
— Lirtosiast
1
Was mir am besten gefällt, ist, wie Sie einen Weg gefunden haben, 6 Sterne in jeder Zeile zu haben, und dann natürlich diejenigen loszuwerden, die Sie nicht wollten.
— Level River St
@steveverrill: Das hat mir auch gefallen, aber ich habe etwas Kürzeres gefunden ...
— Dennis
Cool! (Sie haben etwas Ähnliches mit der Wabe gemacht, oder?) Aber jetzt müssen Sie das überlagerte Bild in Ihrer Erklärung überarbeiten.
— Level River St
27

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.

— Sp3000
quelle
+1 Sehr beeindruckend, 7 Bytes vor meiner Ruby-Antwort. Sie und EDC65 waren Dennis einmal voraus? Wow!
— Level River St
11
Eine Python-Antwort, die mit einer Jam-Antwort konkurriert. Was für eine Zeit am Leben zu sein!
— DJMcMayhem
3
Mir gefällt, wie der Wert i=0selbst gedruckt wird.
— Xnor
8

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.
— vacawama
quelle
2
Du hast es tatsächlich geschafft, die Flagge zu komprimieren! Ich hoffe, Sie veröffentlichen eine Erklärung, wenn Sie mit dem Golfen fertig sind. Ich würde sehr gerne wissen, wie das funktioniert.
— Dennis
Ich werde eine Erklärung posten. Ich spiele immer noch Golf!
— Vacawama
7

/// : 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
— Mann bei der Arbeit
quelle
7

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>
Erweitern Sie das Snippet

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>
Erweitern Sie das Snippet

— edc65
quelle
4
+1 für den Aufruf von ES5 patriotischer
— Pete TNT
6

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
— Level River St
quelle
Hoppla, ich habe vergessen, die Seite neu zu laden, bevor ich überprüft habe, ob eine Ruby-Antwort bereits vorhanden ist. Da sich meine Antwort nicht wesentlich unterscheidet, habe ich sie gelöscht. Fühlen Sie sich frei, jedes gute Teil zu verwenden, das Sie darin finden können.
— Manatwork
@manatwork Ich sehe nicht, dass du es löschen musstest, es war kürzer als meins und ich hatte es bereits hochgeladen. Es gab einige Ruby-Tricks, die ich nicht kannte, ich bin neu in Ruby. Ich bin auf 104 gekommen, indem ich die beste von beiden Antworten verwende, was die kürzeste Antwort in einer herkömmlichen Sprache ist. Ich verstehe nicht , warum ich das nutzen kann mapin der Mitte der puts aber ich kann es nicht selbst verwenden, auch wenn ich es mit Klammern umgeben: puts((0.18).map{}). Wenn Sie weitere Verbesserungen bemerken, lassen Sie es mich wissen oder machen Sie Ihre eigene Antwort rückgängig und posten Sie sie dort.
— Level River St
Ich bin beeindruckt, dass Ruby rjusteine Saite nehmen kann und nicht nur einen Buchstaben. Schade, dass Python das nicht kann ...
— Sp3000
3

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

— Tödlich
quelle
Ich hasse es, eine bestehende Antwort zu brechen, aber die erste Version hatte 11 statt 13 Streifen. Sonst habe ich nichts geändert. Sie können den Bearbeitungsverlauf überprüfen, um zu sehen, was ich geändert habe. Das tut mir leid.
— DJMcMayhem
@DJMcMayhem Behoben, musste nur zwei Zahlen ändern und änderte nicht die Länge der Antwort, also ist alles gut
— Fatalize
1

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.

— openaddr
quelle
Guter erster Versuch. Dies scheint jedoch nicht das |am Anfang jeder Zeile stehende zu drucken ...
— Spikatrix
Ihr Code in 198 Bytes:i;c(){puts("0");for(;i<37;i++){char b[58]="|";if(i<21){memset(b,!((i-1)%3)?35:32,56);if(i<10)memcpy(b," * * * * * * "+((i%2)?0:2),23);b[56]='|';}if(!i||i==20){memset(b,45,57);}puts(b);}}
— Spikatrix
@Cool Guy: Danke für den Haken. Ich habe vergessen, das '|' Zurück zum zweiten Ausdruck vom Initialisierer. Ich habe versucht, Ihren Code mit GCC unter Cygwin auszuführen, aber die Formatierung ist deaktiviert. Muss ich etwas Besonderes tun, um es auszuführen, oder werden beim Kompilieren Flags benötigt?
— openaddr
Keine speziellen Flags erforderlich. Testen Sie es hier Golf es mehr mit 45anstelle von '-'und 35anstelle von '#'und 32anstelle von' '
— Spikatrix
@Cool Guy: Guter Vorschlag zu den Zeichencodierungswerten. Und guter Fang auf der i == 0, die ich übersehen habe. Ich denke, Ihr ursprünglicher Code hat aufgrund der zweiten Puts () nicht funktioniert, aber das war teilweise mein Fehler, da ich vergessen habe, die Position des "|" zurückzusetzen, und es so aussah, als ob der Puffer die gesamte Zeichenfolge enthielt. Der Code in dem Link, den Sie mit printf am Ende angegeben haben, funktioniert jetzt.
— openaddr
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.