29

La sfida a tema per il Giorno dell'Indipendenza Speciale (USA) per te oggi. Devi scrivere un programma che stampa questa rappresentazione di arte ascii de La bandiera americana.

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

Sono consentiti spazi finali su ogni riga, nonché una nuova riga finale.

Nota che questo non è esattamente come dovrebbe apparire la bandiera, ma è il più vicino che potrei ottenere con ASCII.

Come al solito, si tratta di code-golf, quindi si applicano scappatoie standard e vince la risposta più breve in byte!

code-golf ascii-art kolmogorov-complexity

— DJMcMayhem
fonte

È consentito lo spazio bianco finale?

— Dennis,

@Dennis finché non è eccessivo non vedo perché no. Quindi una nuova riga finale è OK.

— DJMcMayhem

9

Vorrei rendere questo un contest pop e vedere chi stampa la bandiera più realistica.

— Hosch250,

7

@ Hosch250 Sarebbe chiuso come "concorso artistico"

— Sp3000,

1

@steveverrill Sì, ma potremmo disegnare una bandiera che si increspa nella brezza, forse.

— Hosch250,

21

CJam, 184 120 109 101 76 74 69 67 64 62 58 byte

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

Provalo online nell'interprete CJam .

Idea

La parte più interessante della bandiera è il motivo a stelle e strisce.

Se ripetiamo due spazi e un segno numerico 56 volte e aggiungiamo una barra verticale a ciascuno, otteniamo

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

Ripetendo questo schema 7 volte e scartando le prime due righe, otteniamo le strisce:

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

Ora, se ripetiamo la stringa " * "50 volte e dividiamo il risultato in blocchi di lunghezza 22, otteniamo le stelle:

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

Lo spazio bianco è un po 'spento, ma possiamo sistemarlo eliminando l'ultimo pezzo e aggiungendo uno spazio a quelli rimanenti.

Ora, se sovrapponiamo strisce e stelle, otteniamo

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

Tutto quello che resta da fare è aggiungere due linee di 57 trattini, aggiungere una colonna di 37 barre verticali e mettere la ciliegia in cima.

Codice

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
fonte

13

Per un brevissimo momento magico ti stavo battendo

— edc65

2

Non capita tutti i giorni di vedere qualcuno scrivere un programma CJam 120 byte troppo a lungo.

— lirtosiast

1

Quello che mi piace di più è il modo in cui hai trovato il modo di avere 6 stelle su ogni linea, quindi di liberarti di quelle che non volevi.

— Level River St

@steveverrill: mi è piaciuto anche quello, ma ho trovato qualcosa di più corto ...

— Dennis

Freddo! (Hai fatto qualcosa di simile con il nido d'ape, vero?) Ma ora devi rivedere l'immagine sovrapposta nella tua spiegazione.

— Level River St

27

Python 2, 113 byte

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)

Tagli di stringa e controlli modulo a bizzeffe.

— SP3000
fonte

+1 Molto impressionante, 7 byte prima della mia risposta rubino. Sia tu che EDC65 eravate davanti a Dennis contemporaneamente? Wow!

— Level River St

11

Una risposta Python in competizione con una risposta CJAM. Che momento di essere vivi!

— DJMcMayhem

3

Mi piace come il valore i=0stesso viene stampato.

— xnor

8

Brainf ** k, 3355 3113 1598 1178 782 byte

Che lingua è?

Ecco la versione ottimizzata a mano con 28 loop. Penso di aver preso tutto questo fino in fondo.

Ecco la corsa su ideone.com :

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

Come funziona?

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

Questo programma utilizza 10 posizioni di memoria:

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

Linea 1

Questa riga imposta i caratteri ASCII nei registri da 2 a 7 (principalmente). Alcune modifiche vengono eseguite in seguito.
Questo codice primi mette 3 nel registro 0 e quindi loop 3 volte incrementali registro 1 quattro volte ogni ciclo: +++[>++++<-]. Quindi il risultato finale è che il registro 0 è 0 e il registro 1 è 12.
Il 12 viene utilizzato come contatore di loop per il loop successivo. Per 12 volte attraverso il loop, i registri 2, 3 e 4 vengono incrementati di 3 volte, il registro 5 viene incrementato di 10 volte, il registro 6 viene incrementato 1 volta e il registro 7 viene incrementato 4 volte. Alla fine di questo ciclo, contengono: R2 (36), R3 (36), R4 (36), R5 (120), R6 (12), R7 (48). Dopo che il registro di loop 2 è stato incrementato di 6 volte, il registro 3 viene ridotto di 4 volte e il registro 4 viene diminuito una volta. A questo punto, i valori sono: R2 (42), R3 (32), R4 (35), R5 (120), R6 (12), R7 (48). Tutti tranne i registri 5 e 6 contengono i loro valori ASCII iniziali.
Viene emesso il successivo registro 7, "0"nella parte superiore della bandiera!
Il successivo registro 6 viene decrementato due volte a 10 (ASCII newline) e viene emesso. Fatto con la prima linea della bandiera!

Linea 2

Innanzitutto incrementa il registro 5 di 4 che lo rende "|"(ASCII 124) e lo emette.
Quindi decrementa il registro 7 di tre cambiandolo da "0"(ASCII 48) a "-"(ASCII 45) e lo emette.
Successivamente inserisce 7 nel contatore loop 3 (registro 8) e esegue 7 cicli, scrivendo 8 trattini ogni volta per un totale di 7 * 8 = 56 trattini.
Alla fine termina emettendo una nuova riga.

Linea 3

Questa riga contiene due loop.
Il primo ciclo scrive " * "5 volte.
Quindi " * "è scritto
Il secondo loop viene ripetuto 4 volte scrivendo 8 "#"per un totale di 32.
Quindi "#", "|"e "\n"sono scritti.

Linee 4 - 11

Queste linee usano la stessa tecnica della linea 3 per scrivere le stelle e le strisce della bandiera.

Linea 12

Questa riga avvia un ciclo che viene eseguito 3 volte.
Il loop termina alla linea 17.

Linea 13

Scrive una striscia che attraversa la bandiera.
Utilizza un ciclo che viene eseguito 7 volte scrivendo "#"8 volte ogni volta attraverso il ciclo.

Linea 14

L'inizio di un ciclo che viene eseguito 2 volte.

Linea 15

Scrive una striscia che attraversa la bandiera.
Utilizza un ciclo che viene eseguito 7 volte scrivendo " "8 volte ogni volta attraverso il ciclo.

Riga 16

Fine dell'anello interno che è iniziato alla linea 14.

Linea 17

Fine dell'anello esterno che è iniziato alla linea 13.

Linea 18

Disegna la striscia inferiore della bandiera.

Linea 19

Disegna il bordo inferiore della bandiera.

Linea 20

Disegna l'asta della bandiera.
Ripeti 8 volte, scrivendo "|"e newline due volte ogni volta attraverso il ciclo.

— vacawama
fonte

2

Sei riuscito a comprimere la bandiera! Spero che pubblichi una spiegazione quando hai finito di giocare a golf. Mi piacerebbe molto sapere come funziona.

— Dennis,

Posterò una spiegazione Sto ancora giocando a golf!

— vacawama,

7

/// : 225 caratteri

/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

— uomo al lavoro
fonte

7

JavaScript ( ES6 ), 153 156

Usando la stringa del modello, c'è 1 newline che è significativa e contata

Prova a eseguire lo snippet di seguito (essendo EcmaScript 6, solo 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>

Espandi frammento

Per essere ancora più patriottico, ecco la versione di 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>

Espandi frammento

— edc65
fonte

4

+1 per chiamare ES5 più patriottico

— Pete TNT

6

Rubino, 104 102 byte

Utilizzando le idee della risposta Ruby di ManAtWork con il permesso.

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

Rubino, 127 121 112 byte

Virgolette modificate ?nell'array usato anziché in base al colore della striscia. usato condizionale anziché formula per la lunghezza della striscia.

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

Il trucco qui è disegnare le strisce (sia rosse / #sia bianche / space) alla lunghezza corretta, quindi giustificarle a destra, riempiendole di stelle. Ruby rjustci consente di specificare la stringa di riempimento, che si alterna tra " * "e " *".

Versione originale, 127 byte

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
fonte

Oops, ho dimenticato di ricaricare la pagina prima di verificare se esiste già una risposta di Ruby. Poiché la mia risposta non è significativamente diversa, l'ho cancellata. Sentiti libero di usare qualsiasi buona parte che potresti trovare in esso.

— arte dal

@manatwork Non vedo che dovevi eliminarlo, era più corto del mio e l'avevo già votato. C'erano alcuni trucchi di Ruby lì dentro che non sapevo, sono nuovo di Ruby. Sono sceso a 104 usando la migliore delle due risposte, che è la risposta più breve in una lingua convenzionale. Non capisco il motivo per cui posso usare la mapin mezzo al puts ma non posso usarlo da solo, anche se mi circondo con parentesi: puts((0.18).map{}). Se vedi ulteriori miglioramenti, fammelo sapere o ripristinare la tua risposta e pubblicarla lì.

— Level River St

Sono impressionato dal fatto che Ruby rjustpossa prendere una corda e non solo un carattere. Peccato che Python non possa farlo ...

— Sp3000,

3

SWI-Prolog, 275 byte

In una lingua di origine francese, che è abbastanza adatta

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

Vedi il risultato qui

— Fatalize
fonte

Odio infrangere una risposta esistente, ma la prima versione aveva 11 strisce invece di 13. Non ho cambiato nient'altro. Puoi controllare la cronologia delle modifiche per vedere cosa ho cambiato. Mi dispiace per quello.

— DJMcMayhem

@DJMcMayhem Risolto, avevo solo bisogno di cambiare due numeri e non ha cambiato la lunghezza della risposta, quindi va bene

— Fatalizza il

1

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

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

modifica: aggiunti alcuni suggerimenti di Cool Guy e utilizzato?: per sostituire alcune dichiarazioni if.

modifica: rimosso overflow \ prevenzione e usato limitatore di lunghezza stringa in printf.

modifica: rielaborato entrambi i condizionali memset.

modifica: spostato mette ("0") all'interno dell'intestazione for per rimuovere il suo punto e virgola.

modifica: leggero refactoring per ottenere 11 byte in più.

— openaddr
fonte

Buon primo tentativo. Ma questo non sembra stampare |all'inizio di ogni riga ...

— Spikatrix il

Il tuo codice in 198 byte:

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 il

@Cool Guy: Grazie per la cattura. Ho dimenticato di spostare il '|' torna alla seconda stampa dall'inizializzatore. Ho provato a far funzionare il tuo codice utilizzando GCC sotto Cygwin, ma la formattazione è disattivata. C'è qualcosa di speciale che devo fare per eseguirlo o eventuali flag necessari al momento della compilazione?

— openaddr,

Non sono richieste bandiere speciali. 45'-'35'#'32' '

— Provalo

@Cool Guy: buon suggerimento sui valori di codifica dei caratteri. E buona cattura su i == 0 che ho trascurato. Penso che il tuo codice iniziale non funzionasse a causa del secondo put (), ma era in parte colpa mia perché dimenticando di cambiare la posizione "|", sembrava che il buffer contenesse l'intera stringa. Il codice nel link che hai fornito usando printf alla fine funziona ora.

— openaddr,

Stampa la bandiera americana!

CJam, 184 120 109 101 76 74 69 67 64 62 58 byte

Idea

Codice

Python 2, 113 byte

Brainf ** k, 3355 3113 1598 1178 782 byte

Come funziona?

Linea 1

Linea 2

Linea 3

Linee 4 - 11

Linea 12

Linea 13

Linea 14

Linea 15

Riga 16

Linea 17

Linea 18

Linea 19

Linea 20

/// : 225 caratteri

JavaScript ( ES6 ), 153 156

Rubino, 104 102 byte

Rubino, 127 121 112 byte

SWI-Prolog, 275 byte

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