¡Imprime la bandera americana!

29

Desafío temático especial del Día de la Independencia (EE. UU.) Para ti hoy. Debe escribir un programa que imprima esta representación de arte ascii de La bandera estadounidense.

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

Se permiten espacios finales en cada línea, así como una nueva línea final.

Tenga en cuenta que esta no es la forma en que debería verse la bandera, pero es lo más cerca que podría estar con ASCII.

Como de costumbre, este es el código de golf, por lo que se aplican las lagunas estándar y gana la respuesta más corta en bytes.

code-golf  ascii-art  kolmogorov-complexity 
— DJMcMayhem
fuente
¿Se permite el espacio en blanco al final?
— Dennis
@Dennis mientras no sea excesivo, no veo por qué no. Entonces una nueva línea final está bien.
— DJMcMayhem
9
Haría de esto un concurso pop y vería quién imprime la bandera más realista.
— Hosch250
77
@ Hosch250 Eso terminaría cerrado como "concurso de arte"
— Sp3000
1
@steveverrill Sí, pero podríamos dibujar una bandera ondeando en la brisa, tal vez.
— Hosch250

Respuestas:

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

Pruébelo en línea en el intérprete de CJam .

Idea

La parte más interesante de la bandera es el patrón de barras y estrellas.

Si repetimos dos espacios y un signo de número 56 veces y agregamos una barra vertical a cada uno, obtenemos

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

Repitiendo este patrón 7 veces y descartando las dos primeras líneas, obtenemos las rayas:

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

Ahora, si repetimos la cadena " * "50 veces y dividimos el resultado en trozos de longitud 22, obtenemos las estrellas:

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

El espacio en blanco está un poco apagado, pero podemos solucionarlo eliminando el último fragmento y agregando un espacio a los restantes.

Ahora, si superponemos rayas y estrellas, obtenemos

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

Todo lo que queda por hacer es agregar dos líneas de 57 guiones, agregar una columna de 37 barras verticales y poner la guinda en la parte superior.

Código

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
fuente
13
Durante un breve momento mágico, te estaba golpeando
— edc65
2
No todos los días ves a alguien escribir un programa CJam de 120 bytes demasiado tiempo.
— lirtosiast el
1
Lo que más me gusta es cómo encontraste una manera de tener 6 estrellas en cada línea, y luego, naturalmente, deshacerte de las que no querías.
— Level River St
@steveverrill: eso también me gustó, pero encontré algo más corto ...
— Dennis
¡Guay! (Hiciste algo similar con el panal, ¿verdad?) Pero ahora necesitas revisar la imagen superpuesta en tu explicación.
— 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)

Corte de cuerdas y cheques de módulo en abundancia.

— Sp3000
fuente
+1 Muy impresionante, 7 bytes por delante de mi respuesta rubí. ¿Tanto usted como EDC65 estuvieron por delante de Dennis al mismo tiempo? ¡Guauu!
— Level River St
11
Una respuesta de Python que compite con una respuesta de cjam. ¡Qué tiempo para estar vivo!
— DJMcMayhem
3
Me gusta cómo i=0se imprime el valor .
— xnor
8

Brainf ** k, 3355 3113 1598 1178 782 bytes

¿Que idioma es este?

Aquí está la versión optimizada para la mano con 28 bucles. Creo que he llevado esto lo más lejos posible.

Aquí está la carrera en ideone.com :

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

¿Como funciona esto?

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

Este programa usa 10 ubicaciones de 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

Línea 1

  • Esta línea configura los caracteres ASCII en los registros 2 a 7 (principalmente). Algunos ajustes se realizan más tarde.
  • Este código primeros pone 3 en el registro 0, y después los bucles de 3 veces de incremento registro 1 cuatro veces cada bucle: +++[>++++<-]. Entonces el resultado final es que el registro 0 es 0, y el registro 1 es 12.
  • El 12 se utiliza como contador de bucle para el siguiente bucle. Por 12 veces a través del ciclo, los registros 2, 3 y 4 se incrementan 3 veces, el registro 5 se incrementa 10 veces, el registro 6 se incrementa 1 vez y el registro 7 se incrementa 4 veces. Al final de este ciclo, contienen: R2 (36), R3 (36), R4 (36), R5 (120), R6 (12), R7 (48). Después de que el registro de bucle 2 se incrementa 6 veces, el registro 3 se disminuye 4 veces y el registro 4 se decrementa una vez. En este punto, los valores son: R2 (42), R3 (32), R4 (35), R5 (120), R6 (12), R7 (48). Todos los registros excepto 5 y 6 contienen sus valores ASCII iniciales.
  • El siguiente registro 7 sale, ¡ "0"en la parte superior de la bandera!
  • El siguiente registro 6 se reduce dos veces a 10 (nueva línea ASCII) y la salida. Hecho con la primera línea de la bandera!

Línea 2

  • Primero, incrementa el registro 5 por 4, lo que lo hace "|"(ASCII 124) y lo genera.
  • Luego disminuye el registro 7 por tres cambiándolo de "0"(ASCII 48) a "-"(ASCII 45) y lo emite.
  • Luego pone 7 en el contador de bucles 3 (registro 8) y bucles 7 veces, escribiendo 8 guiones cada vez para un total de 7 * 8 = 56 guiones.
  • Finalmente termina generando una nueva línea.

Línea 3

  • Esta línea contiene dos bucles.
  • El primer bucle escribe " * "5 veces.
  • Entonces " * "se escribe
  • El segundo bucle repite 4 veces escribiendo 8 "#"para un total de 32.
  • Entonces "#", "|"y "\n"están escritos.

Líneas 4 - 11

  • Estas líneas usan la misma técnica que la línea 3 para escribir las estrellas y franjas de la bandera.

Línea 12

  • Esta línea inicia un ciclo que se ejecuta 3 veces.
  • El bucle termina en la línea 17.

Línea 13

  • Escribe una tira que cruza la bandera.
  • Utiliza un bucle que se ejecuta 7 veces escribiendo "#"8 veces cada vez a través del bucle.

Línea 14

  • El inicio de un ciclo que se ejecuta 2 veces.

Línea 15

  • Escribe una tira que cruza la bandera.
  • Utiliza un bucle que se ejecuta 7 veces escribiendo " "8 veces cada vez a través del bucle.

Línea 16

  • Fin del bucle interno que comenzó en la línea 14.

Línea 17

  • Fin del bucle externo que comenzó en la línea 13.

Línea 18

  • Dibuja la franja inferior de la bandera.

Línea 19

  • Dibuja el borde inferior de la bandera.

Línea 20

  • Dibuja el asta de la bandera.
  • Bucles 8 veces, escribiendo "|"y nueva línea dos veces cada vez a través del bucle.
— vacawama
fuente
2
¡Realmente lograste comprimir la bandera! Espero que publiques una explicación cuando termines de jugar golf. Me gustaría mucho saber cómo funciona esto.
— Dennis
Publicaré una explicación. ¡Todavía estoy jugando al golf!
— vacawama
7

/// : 225 caracteres

/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
— hombre trabajando
fuente
7

JavaScript ( ES6 ), 153 156

Usando una cadena de plantilla, hay 1 nueva línea que es significativa y contada

Pruebe a ejecutar el fragmento a continuación (siendo 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>
Expandir fragmento

Para ser aún más patriótico, aquí está la versión 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>
Expandir fragmento

— edc65
fuente
44
+1 por llamar a ES5 más patriótico
— Pete TNT
6

Ruby, 104 102 bytes

Usando ideas de la respuesta de Ruby de ManAtWork con permiso.

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

Ruby, 127121121 bytes

Se cambiaron las comillas a la ?matriz utilizada en lugar de condicional para el color de la franja. usado condicional en lugar de fórmula para la longitud de la franja.

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

El truco aquí es dibujar las rayas (tanto rojas / #como blancas / space) a la longitud correcta, luego justificarlas a la derecha, rellenando con estrellas. Ruby's rjustnos permite especificar la cadena de relleno, que alterna entre " * "y " *".

Versión original, 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
fuente
Vaya, olvidé volver a cargar la página antes de comprobar si ya existe una respuesta de Ruby. Como mi respuesta no es significativamente diferente, la eliminé. Siéntase libre de usar cualquier parte buena que pueda encontrar en ella.
— manatwork
@manatwork No veo que necesitaras eliminarlo, era más corto que el mío y ya lo había votado. Había algunos trucos de Ruby allí que no conocía, soy nuevo en Ruby. Tengo 104 usando la mejor de las dos respuestas, que es la respuesta más corta en un lenguaje convencional. No entiendo por qué puedo utilizar el mapen el medio de la puts pero no puedo usarlo por sí solo, aunque lo rodean con paréntesis: puts((0.18).map{}). Si ve alguna mejora adicional, avíseme o recupere su propia respuesta y publíquela allí.
— Level River St
Estoy impresionado de que Ruby rjustpueda tomar una cuerda y no solo un char. Lástima que Python no pueda hacer eso ...
— Sp3000
3

SWI-Prolog, 275 bytes

En un idioma de origen francés, que es algo apropiado

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

Mira el resultado aquí

— Fatalizar
fuente
Odio romper una respuesta existente, pero la primera versión tenía 11 franjas en lugar de 13. No cambié nada más. Puedes consultar el historial de edición para ver qué he cambiado. Lo siento por eso.
— DJMcMayhem
@DJMcMayhem Solucionado, solo necesitaba cambiar dos números y no cambió la longitud de la respuesta, por lo que todo está bien
— 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);}}

editar: agregó algunas de las sugerencias de Cool Guy e hizo uso de?: para reemplazar algunas declaraciones if.

edit: eliminó la prevención de desbordamiento \ 0 y usó el limitador de longitud de cadena en printf.

editar: reelaborado ambos condicionales memset.

editar: movió put ("0") dentro del encabezado for para eliminar su punto y coma.

editar: leve refactorización para obtener 11 bytes más.

— openaddr
fuente
Buen primer intento. Pero esto no parece imprimir |al comienzo de cada línea ...
— Spikatrix
Su código en 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: Gracias por la captura. Olvidé mover el '|' volver a la segunda printf desde el inicializador. Intenté ejecutar su código usando GCC en Cygwin, pero el formato está desactivado. ¿Hay algo especial que deba hacer para ejecutarlo o algún indicador necesario en el momento de la compilación?
— openaddr
No se requieren banderas especiales. Compruébalo aquí Golf más utilizando 45en lugar de '-'y 35en lugar de '#'y 32en lugar de' '
— Spikatrix
@Cool Guy: buena sugerencia sobre los valores de codificación de caracteres. Y buena captura en el i == 0 que pasé por alto. Creo que su código inicial no funcionaba debido al segundo put (), pero eso fue en parte mi culpa porque al olvidar cambiar la posición de "|", hizo que pareciera que el búfer contenía toda la cadena. El código en el enlace que proporcionó usando printf al final funciona ahora.
— openaddr
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.