Specjalne wyzwanie dla Ciebie z okazji Dnia Niepodległości (USA) już dziś. Musisz napisać program, który wydrukuje to ascii-artystyczne przedstawienie flagi amerykańskiej.

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

Dozwolone są końcowe spacje w każdej linii, a także jedna nowa linia.

Pamiętaj, że nie jest to taki sposób, w jaki powinna wyglądać flaga, ale jest to najbliższe osiągnięcie z ASCII.

Jak zwykle jest to gra w golfa, więc obowiązują standardowe luki i wygrywa najkrótsza odpowiedź w bajtach!

CJam, 184 120 109 101 76 74 69 67 64 62 58 bajtów

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

Wypróbuj online w interpretatorze CJam .

Pomysł

Najciekawszą częścią flagi jest wzór gwiazd i pasków.

Jeśli powtórzymy 56 razy spacje i znak liczbowy i dołączymy do nich pionowy pasek, otrzymamy

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

Powtarzając ten wzór 7 razy i odrzucając pierwsze dwie linie, otrzymujemy paski:

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

Teraz, jeśli powtórzymy łańcuch " * "50 razy i podzielimy wynik na kawałki o długości 22, otrzymamy gwiazdy:

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

Białe znaki są trochę wyłączone, ale możemy to naprawić, eliminując ostatni fragment i dodając spację do pozostałych.

Teraz, jeśli nałożymy paski i gwiazdy, otrzymamy

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

Wystarczy dodać dwie linie po 57 myślników, kolumnę 37 pionowych pasków i umieścić wisienkę na wierzchu.

Kod

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 bajtów

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)

Przecinanie sznurków i sprawdzanie modulo.

Brainf ** k, 3355 3113 1598 1178 782 bajtów

Co to za język?

Oto ręcznie zoptymalizowana wersja z 28 pętlami. Myślę, że posunąłem się tak daleko, jak to możliwe.

Oto przebieg na ideone.com :

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

Jak to działa?

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

Ten program wykorzystuje 10 lokalizacji pamięci:

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

Linia 1

• Ten wiersz ustawia znaki ASCII w rejestrach od 2 do 7 (głównie). Niektóre poprawki są wykonywane później.
• Kod ten formułuje 3 w rejestrze 0, a następnie 3 razy pętli inkrementację rejestru 1 cztery razy pętlę: +++[>++++<-]. Wynik końcowy jest taki, że rejestr 0 to 0, a rejestr 1 to 12.
• Licznik 12 jest używany jako licznik pętli dla następnej pętli. Przez 12 razy w pętli rejestry 2, 3 i 4 są zwiększane 3 razy, rejestr 5 jest zwiększany 10 razy, rejestr 6 jest zwiększany 1 raz, a rejestr 7 jest zwiększany 4 razy. Na końcu tej pętli zawierają: R2 (36), R3 (36), R4 (36), R5 (120), R6 (12), R7 (48). Po tym, jak rejestr pętli 2 jest zwiększany 6 razy, rejestr 3 jest zmniejszany 4 razy, a rejestr 4 jest zmniejszany raz. W tym momencie wartości są następujące: R2 (42), R3 (32), R4 (35), R5 (120), R6 (12), R7 (48). Wszystkie rejestry oprócz 5 i 6 zawierają ich początkowe wartości ASCII.
• Następny rejestr 7 jest wyprowadzany, "0"na górze flagi!
• Następny rejestr 6 jest dwukrotnie zmniejszany do 10 (nowa linia ASCII) i wysyłany. Zrobione z pierwszą linią flagi!

Linia 2

• Najpierw zwiększa rejestr 5 o 4, co czyni go "|"(ASCII 124) i wysyła.
• Następnie zmniejsza rejestr 7 o trzy, zmieniając go z "0"(ASCII 48) na "-"(ASCII 45) i wysyła.
• Następnie wstawia 7 do licznika pętli 3 (rejestr 8) i zapętla 7 razy, zapisując za każdym razem 8 kresek, co daje w sumie 7 * 8 = 56 kresek.
• Wreszcie kończy się wypisaniem nowego wiersza.

Linia 3

• Ta linia zawiera dwie pętle.
• Pierwsza pętla pisze " * "5 razy.
• Potem " * "jest napisane
• Druga pętla zapętla się 4 razy, pisząc 8, "#"co daje w sumie 32.
• Następnie "#", "|"i "\n"są napisane.

Linie 4–11

• Linie te wykorzystują tę samą technikę, co linia 3, aby zapisać gwiazdy i paski flagi.

Linia 12

• Ta linia rozpoczyna pętlę, która działa 3 razy.
• Pętla kończy się na linii 17.

Linia 13

• Pisze pasek przechodzący przez flagę.
• Wykorzystuje pętlę, która działa 7 razy, zapisując "#"8 razy za każdym razem przez pętlę.

Linia 14

• Początek pętli, która działa 2 razy.

Linia 15

• Pisze pasek przechodzący przez flagę.
• Wykorzystuje pętlę, która działa 7 razy, zapisując " "8 razy za każdym razem przez pętlę.

Linia 16

• Koniec wewnętrznej pętli, która rozpoczęła się w linii 14.

Linia 17

• Koniec zewnętrznej pętli, która rozpoczęła się w linii 13.

Linia 18

• Rysuje dolny pasek flagi.

Linia 19

• Rysuje dolną granicę flagi.

Linia 20

• Rysuje maszt flagowy.
• Pętle 8 razy, pisanie "|"i nowa linia dwa razy za każdym razem przez pętlę.

/// : 225 znaków

/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

Używając ciągu szablonu, istnieje 1 nowy wiersz, który jest znaczący i zliczany

Przetestuj poniższy fragment kodu (tylko EcmaScript 6, tylko 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>

Aby być jeszcze bardziej patriotycznym, oto wersja 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>

Rubinowy, 104 102 bajtów

Korzystanie z pomysłów z Ruby ManAtWork w odpowiedzi za zgodą.

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

Rubin, 127 121 112 bajtów

Zmieniono cudzysłowy na ?używaną tablicę zamiast warunkowo na kolor paska. użył warunku zamiast wzoru dla długości paska.

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

Sztuczka polega na tym, aby narysować paski (zarówno czerwone / jak #i białe / space) na odpowiednią długość, a następnie odpowiednio je uzasadnić, wypełniając je gwiazdkami. Ruby's rjustpozwala nam określić łańcuch dopełniający, który jest na przemian z " * "i " *".

Wersja oryginalna, 127 bajtów

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 bajtów

W języku francuskiego pochodzenia, co jest dość pasujące

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

Zobacz wynik tutaj

C, 235 211 208 205 203 198 197 186 bajtów

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

edycja: dodano niektóre sugestie Cool Guy i wykorzystałem?: do zastąpienia niektórych instrukcji if.

edycja: usunięto zapobieganie przepełnieniu \ 0 i zastosowano zamiast tego ogranicznik długości łańcucha w printf.

edycja: przerobiono oba warunki warunkowe zestawu.

edit: przeniesiono wstawia („0”) do nagłówka for, aby usunąć jego średnik.

edycja: nieznaczne refaktoryzacja, aby uzyskać jeszcze 11 bajtów.