Wydrukuj amerykańską flagę!

29

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!

code-golf  ascii-art  kolmogorov-complexity 
— DJMcMayhem
źródło
Czy dozwolone są końcowe białe znaki?
— Dennis
@Dennis, o ile nie jest nadmierny, nie rozumiem, dlaczego nie. Tak więc jedna nowa linia jest OK.
— DJMcMayhem
9
Zrobiłbym z tego popowy konkurs i zobaczyłem, kto drukuje najbardziej realistyczną flagę.
— Hosch250
7
@ Hosch250 Skończy się to jako „konkurs plastyczny”
— Sp3000,
1
@steveverrill Tak, ale być może moglibyśmy narysować flagę falującą na wietrze.
— Hosch250

Odpowiedzi:

21

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.
— Dennis
źródło
13
Przez bardzo krótki, magiczny moment
— pokonałem
2
Nie każdego dnia ktoś pisze program CJam o 120 bajtów za długo.
— lirtosiast
1
Najbardziej podoba mi się to, jak znalazłeś sposób na 6 gwiazdek na każdej linii, a następnie naturalnie pozbyłeś się tych, których nie chciałeś.
— Level River St
@steveverrill: Też mi się podobało, ale znalazłem coś krótszego ...
— Dennis
Fajne! (Zrobiłeś coś podobnego do plastra miodu, prawda?) Ale teraz musisz zmienić nałożony obraz w swoim wyjaśnieniu.
— Level River St
27

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.

— Sp3000
źródło
+1 Bardzo imponujące, 7 bajtów przed moją rubinową odpowiedzią. Zarówno ty, jak i EDC65 wyprzedzaliście kiedyś Dennisa? łał!
— Level River St
11
Odpowiedź pythonowa konkurująca z odpowiedzią cjam. Cóż za czas na życie!
— DJMcMayhem
3
Podoba mi się, jak i=0drukowana jest sama wartość .
— xnor
8

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ę.
— vacawama
źródło
2
Udało ci się skompresować flagę! Mam nadzieję, że opublikujesz wyjaśnienie, kiedy skończysz grać w golfa. Bardzo chciałbym wiedzieć, jak to działa.
— Dennis
Wyślę wyjaśnienie. Nadal gram w golfa!
— vacawama,
7

/// : 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
— człowiek w pracy
źródło
7

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>
Rozwiń fragment kodu

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>
Rozwiń fragment kodu

— edc65
źródło
4
+1 za nazwanie ES5 bardziej patriotycznym
— Pete TNT
6

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
— Level River St
źródło
Ups, zapomniałem ponownie załadować stronę przed sprawdzeniem, czy odpowiedź Ruby już istnieje. Ponieważ moja odpowiedź nie różni się znacząco, usunąłem ją. Zachęcamy do skorzystania z każdej dobrej części, jaką można w nim znaleźć.
— manatwork
@manatwork Nie widzę, że trzeba go usunąć, był krótszy niż mój i już go głosowałem. Było tam kilka sztuczek Ruby, których nie znałem, jestem nowy w Ruby. Mam do 104, używając najlepszej z obu odpowiedzi, która jest najkrótszą odpowiedzią w konwencjonalnym języku. Nie rozumiem, dlaczego można używać mapw środku malowniczego puts , ale nie mogę go używać na własną rękę, nawet jeśli otaczają go ze wspornikami: puts((0.18).map{}). Jeśli zobaczysz jakieś dalsze ulepszenia, daj mi znać lub cofnij usunięcie swojej odpowiedzi i opublikuj ją.
— Level River St
Jestem pod wrażeniem, że Ruby rjustmoże wziąć sznurek, a nie tylko znak. Szkoda, że ​​Python nie może tego zrobić ...
— Sp3000,
3

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

— Fatalizować
źródło
Nienawidzę łamać istniejącej odpowiedzi, ale pierwsza wersja miała 11 pasków zamiast 13. Nie zmieniłem nic innego. Możesz sprawdzić historię edycji, aby zobaczyć, co zmieniłem. Przepraszam za to.
— DJMcMayhem
@DJMcMayhem Naprawiono, wystarczyło zmienić tylko dwie liczby i nie zmieniłem długości odpowiedzi, więc wszystko jest w porządku
— Fatalize
1

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.

— openaddr
źródło
Dobra pierwsza próba. Ale to nie wydaje się drukować |na początku każdej linii ...
— Spikatrix
Twój kod w 198 bajtach: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: Dzięki za złapanie. Zapomniałem przenieść „|” powrót do drugiego printf z inicjalizatora. Próbowałem uruchomić Twój kod za pomocą GCC pod Cygwin, ale formatowanie jest wyłączone. Czy jest coś specjalnego, co muszę zrobić, aby go uruchomić lub jakieś flagi potrzebne w czasie kompilacji?
— openaddr
Nie wymaga specjalnych flag. Przetestuj tutaj45'-'35'#'32' '
— Zagraj w
@Cool Guy: Dobra sugestia dotycząca wartości kodowania znaków. I dobry haczyk na i == 0, które przeoczyłem. Myślę, że twój początkowy kod nie działał z powodu drugiego puts (), ale to była częściowo moja wina, ponieważ przez zapomnienie zmiany pozycji "|" z powrotem sprawiało to wrażenie, jakby bufor zawierał cały ciąg. Kod w linku podanym za pomocą printf na końcu już działa.
— openaddr
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.