¡Dibujemos algunas bombas Atari ST!

46

Introducción

El Atari ST era una computadora personal bastante popular desde mediados de los 80 hasta principios de los 90, impulsada por un microprocesador Motorola 68000. En esta máquina, el comportamiento predeterminado del sistema operativo para las excepciones de CPU no capturadas era mostrar una fila de bombas en la pantalla, como se muestra en la siguiente imagen:

fila de bombas

Fuente: https://commons.wikimedia.org/wiki/File:Row_of_bombs.png
NB: Dependiendo de la versión del sistema operativo, los gráficos de la bomba pueden variar ligeramente. Pero tomemos este como referencia.

La cantidad de bombas depende del vector de excepción, siendo las más comunes:

  • ($ 008) Error de autobús: 2 bombas
  • ($ 00c) Error de dirección: 3 bombas
  • ($ 010) Instrucción ilegal: 4 bombas

Gol

Su objetivo es escribir un programa o función que imprima o genere un arte ASCII de tales bombas Atari ST.

Entrada

Un número entero que representa el número de bombas para mostrar. Su código debe admitir los valores más comunes: 2, 3 y 4. Está bien admitir menos y / o más bombas, pero no es obligatorio ni está sujeto a una bonificación.

Salida

La bomba original consiste en un mosaico de 16x16 píxeles, representado aquí tanto en ASCII como en binario:

....##..........    0000110000000000
.#.#..#.........    0101001000000000
.......#........    0000000100000000
#..#....#.......    1001000010000000
..#...#####.....    0010001111100000
......#####.....    0000001111100000
....#########...    0000111111111000
...###########..    0001111111111100
...###########..    0001111111111100
..#############.    0011111111111110
..########.####.    0011111111011110
...#######.###..    0001111111011100
...######.####..    0001111110111100
....#########...    0000111111111000
.....#######....    0000011111110000
.......###......    0000000111000000

En este desafío, cada bomba ASCII debe estirarse al doble de su ancho original para una mejor representación. Por lo tanto, constará de 16 filas de 32 caracteres, que se utilizarán ##para píxeles 'ACTIVADOS' y dos espacios para píxeles 'DESACTIVADOS'. Todas las fichas de bombas deben colocarse una al lado de la otra. Los espacios principales están prohibidos. Los espacios finales también están prohibidos, excepto los que en realidad son parte de la loseta de la bomba (es decir, las columnas 31 y 32) que deben estar presentes. Puede incluir no más de un salto de línea inicial y no más de un salto de línea final.

Ejemplo

A continuación se muestra la salida de referencia para dos bombas, donde los saltos de línea obligatorios se marcan como \ny los saltos de línea adicionales tolerados se marcan como (\n):

(\n)
        ####                            ####                    \n
  ##  ##    ##                    ##  ##    ##                  \n
              ##                              ##                \n
##    ##        ##              ##    ##        ##              \n
    ##      ##########              ##      ##########          \n
            ##########                      ##########          \n
        ##################              ##################      \n
      ######################          ######################    \n
      ######################          ######################    \n
    ##########################      ##########################  \n
    ################  ########      ################  ########  \n
      ##############  ######          ##############  ######    \n
      ############  ########          ############  ########    \n
        ##################              ##################      \n
          ##############                  ##############        \n
              ######                          ######            (\n)

(Por supuesto, otros formatos de salto de línea como \ro \r\npueden usarse igual de bien).

Reglas

Este es el código de golf, por lo que gana la respuesta más corta en bytes. Las lagunas estándar están prohibidas.

code-golf ascii-art kolmogorov-complexity Arnauld
fuente
Noté que ha excluido formas que no son de arte ASCII, por lo que una función de código de máquina Atari ST que se bloquea con la cantidad correcta de bombas no cuenta. (La bomba no está en la fuente, pero el Atari ST tiene glifos divertidos / de huevo de pascua en su conjunto de caracteres nativos, incluidos los personajes 28–31 que son 4 piezas que forman la imagen de JR "Bob" Dobbs de la Iglesia satírica del SubGenius . Recuerdo haber escrito un programa que envió spam a esos 4 glifos en posiciones de pantalla aleatorias, como un ejercicio muy temprano en el uso de llamadas al sistema de dibujo de texto :)
Peter Cordes
1
@PeterCordes: es cierto, debe ser ASCII. Sin embargo, se le permitirá leer los gráficos de la bomba desde el ST ROM ya que no hay una regla que le impida hacerlo. (Solo mencione la versión de TOS en la que se supone que funciona).
Arnauld
1
Oh, GUAU, eso trae recuerdos. Mi primera computadora fue una Atari ST. Recuerdo esas bombas con miedo.
Rod
Aparte: "El número de bombas depende del vector de excepción" - ¡diga qué? ¿Alguna razón por la que no pudieron generar el código / error real? (Nunca tuve un ST, soy del campamento de Amiga ... "Meditación Gurú" y todo eso.)
MrWhite

Respuestas:

20

Jalea , 43 44 bytes

+1 byte: olvidé duplicar los caracteres (¡eso no lo notó nadie!)

“¥vẏ)X;ndĊɓ¡ẹ3ċi}Ịɲ¡P"¦ḊƥṾ’b⁴‘ĖŒṙị⁾ #Ḥs⁴ẋ€³Y

TryItOnline

¿Cómo?

La preparación consistió en comprimir los datos como una codificación de longitud de ejecución de la imagen original:

  • Cuente la longitud de cada ejecución de 1s (espacio) o 0s (hash) en la imagen, ignorando las nuevas líneas: se obtiene una lista [4,2,11,1,1,...]:;
  • Resta uno de cada número; esto da un rango de [0,15];
  • Trate esto como un número base 16 (enumere los valores v, con el índice ien reversa y suma 16**i*v= 19468823747267181273462257760938030726282593096816512166437);
  • Convierta esto a base-250 [5,119,249,42,...]:;
  • Mapa en la página de códigos de Jelly como índices: ¥vẏ)X;ndĊɓ¡ẹ3ċi}Ịɲ¡P

Ahora el código evalúa este número, asigna los 1sys 0al espacio y los caracteres hash *, duplica cada uno, se divide en líneas y repite cada uno el número apropiado de veces.
* En realidad, la implementación se realiza en el módulo 2 para guardar bytes, por lo que los espacios son impares y los hash son pares:

“¥vẏ)X;ndĊɓ¡ẹ3ċi}Ịɲ¡P"¦ḊƥṾ’b⁴‘ĖŒṙị⁾ #Ḥs⁴ẋ€³Y - Main link: n
“¥vẏ)X;ndĊɓ¡ẹ3ċi}Ịɲ¡P"¦ḊƥṾ’                  - base 250 number, as above
                           b⁴                - convert to base 16 (the run length - 1 list)
                             ‘               - increment (vectorises) (the run length list)
                              Ė              - enumerate (pairs each with 1,2,3...)
                               Œṙ            - run length decode
                                              ([1,1,1,1,2,2,3,3,3,3,3,3,3,3,3,3,3,4,5,...])
                                  ⁾ #        - string " #"
                                 ị           - index into (1 based and modular)
                                              (makes a bomb without line feeds)
                                     Ḥ       - double (each char becomes a list of 2 chars)
                                      s⁴     - split into slices of length 16
                                        ẋ€³  - repeat each input, n, times
                                           Y - join with line feeds
Jonathan Allan
fuente
19

05AB1E , 57 55 53 50 bytes

Utiliza la codificación CP-1252 .

•ø6ŒY2l½î€ÈS`L<eÆô‚˜3ª½¨ºE»D2Âô3•b15ôvy1J€D„# è¹×,

Pruébalo en línea!

Explicación

Como la imagen de salida solo consta de 2 caracteres, podemos representarla como un número binario.
Podemos ignorar las nuevas líneas ya que cada línea tiene la misma longitud.
Podemos ignorar el último carácter de cada fila, ya que es el mismo para todas las filas.
Utilizamos la imagen más delgada, ya que ocupa menos espacio y podemos duplicar fácilmente cada carácter más adelante.

Usando 1 para representar el espacio y 0 para representar # obtenemos el número binario:

111100111111111101011011111111111111101111111011011110111111110111000001111111111000001111111100000000011111000000000001111000000000001110000000000000110000000010000111000000010001111000000100001111100000000011111110000000111111111100011111

Luego convertimos esto a base-10 y luego lo comprimimos a base 214, la base máxima en 05AB1E. El resultado de esto es:

•ø6ŒY2l½î€ÈS`L<eÆô‚˜3ª½¨ºE»D2Âô3•

La carne del programa consiste en lo siguiente:

<base encoded string>
  b                     # convert to binary
   15ô                  # slice into pieces of 15
      v                 # for each slice  
       1J               # append a 1       
         €D             # duplicate each character
           „#           # push the string "# "
             è          # use the list of binary digits to index into the string
              ¹×        # repeat string input number of times
                ,       # and print with newline
Emigna
fuente
12

Pyth, 57 56 54 53 51 50 bytes

El código contiene caracteres no imprimibles, así que aquí hay un xxdhexdump reversible .

00000000: 6a2a 4c51 6331 3673 2e65 2a79 6240 2220  j*LQc16s.e*yb@"
00000010: 2322 6b6a 4322 4c49 c142 3c60 0cca 9437  #"kjC"LI.B<`...7
00000020: b383 76bb c246 c86d 4c04 99bd 3614 7022  ..v..F.mL...6.p"
00000030: 3137                                     17

Pruébalo en línea.

PurkkaKoodari
fuente
11

JavaScript (ES6), 159 154 140 136 bytes

Ahorré muchos bytes gracias a @Hedi y @Arnauld

n=>[..."ￏﾵｿﻶ쀇쀇考萃쐇숇ﱿ"].map(x=>(f=q=>q?(q&1?"  ":"##")+f(q>>1):"")(x.charCodeAt()).repeat(n)).join`
`

Eso es 104 caracteres, pero (lamentablemente) 136 bytes UTF-8. La cadena se generó con este fragmento:

Mostrar fragmento de código

Usar en .replacelugar de [...string].mapes igualmente largo:

n=>"ￏﾵｿﻶ쀇쀇考萃쐇숇ﱿ".replace(/./g,x=>(f=q=>q?(q&1?"  ":"##")+f(q>>1):"")(x.charCodeAt()).repeat(n)+`
`)

Cómo funciona

Como cada fila de datos sin procesar puede representarse como un número de 16 bits, podemos almacenar el archivo completo en una cadena de 16 caracteres. El algoritmo de compresión toma cada fila binaria, la voltea y la invierte (dado que cada fila en el original termina en 0 , cada fila en la versión modificada ahora comienza con un 1 ), luego la convierte en un carácter y concatena los caracteres resultantes .

Para descomprimirlo, necesitamos extraer el código de char y convertir su representación binaria en una cadena de hashes y espacios. Esto se puede hacer con una función recursiva, así:

(f=q=>q?(q&1?"  ":"##")+f(q>>1):"")(x.charCodeAt())

frepetidamente toma el último bit de q, seleccionando dos espacios si es 1 o dos hashes si es 0, luego concatena eso con el resultado de ejecutarse fen el resto de q. Esto se ejecuta x.charCodeAt(), convirtiendo el código char en la cadena correcta de espacios y hashes.

(Hubo mucho más drama aquí antes, pero la técnica de ahorro de 4 bytes borró todo eso).

Después de eso, podemos repetir los ntiempos de la cadena y agregar una nueva línea. Este es el método de descompresión más corto que he encontrado, pero no dude en sugerir cualquier método posiblemente más corto.

Otros intentos de comprimir la cadena:

n=>[48,74,128,265,1988,1984,8176,16376,16376,32764,31740,15352,15864,8176,4064,896].map(x=>(f=q=>q?(q&1?"  ":"##")+f(q>>1):"")(65535-x).repeat(n)).join`
`
n=>"1c,22,3k,7d,1j8,1j4,6b4,cmw,cmw,pa4,oho,bug,c8o,6b4,34w,ow".split`,`.map(x=>(f=q=>q?(q&1?"  ":"##")+f(q>>1):"")(65535-parseInt(x,36)).repeat(n)).join`
`
n=>"30,4a,80,109,7c4,7c0,1ff0,3ff8,3ff8,7ffc,7bfc,3bf8,3df8,1ff0,fe0,380".split`,`.map(x=>(f=q=>q?(q&1?"  ":"##")+f(q>>1):"")('0x'+x^65535)).repeat(n)).join`
`

El primero de ellos es 153 bytes, por lo que ninguno de ellos se acerca a 136 ...

ETHproducciones
fuente
Podría guardar algunos bytes con en +x?'##':' 'lugar de" #"[x].repeat(2)
Hedi
@Hedi gracias, sabía que había una manera de jugar al golf.
ETHproductions
2
¿Podría probar directamente los bits en x.charCodeAt()lugar de convertirlos en binarios? (Creo que eso ahorraría unos 8 bytes.)
Arnauld
2
Su algoritmo de compresión suena casi criptográfico .
Justin
1
@Justin Damn, estaba a punto de comentar eso.
user253751
10

Archivo .COM de MS-DOS, 84 bytes

OKAY. Solo por diversión porque no puedo superar los 50 bytes ...

Probado en DOSbox y en MS-DOS 6.22 en una máquina virtual.

En DOSbox, el programa funciona bien, sin embargo, en MS-DOS real, la salida no se mostrará correctamente porque DOS requiere CR-LF en lugar de LF al final de la línea.

(Sin embargo, la salida es correcta).

Una variante de 88 bytes usaría CR-LF al final de la línea.

Aquí está el archivo:

0000  be 32 01 fc ad 89 c3 8a  36 82 00 80 ee 30 b9 10
0010  00 d1 c3 18 d2 80 ca 20  80 e2 23 b4 02 cd 21 cd
0020  21 e2 ee fe ce 75 e7 b2  0a cd 21 ad 85 c0 75 d5
0030  cd 20 00 0c 00 52 00 01  80 90 e0 23 e0 03 f8 0f
0040  fc 1f fc 1f fe 3f de 3f  dc 1f bc 1f f8 0f f0 07
0050  c0 01 00 00

El código del ensamblador (en la sintaxis de AT&T) se ve así:

start:
      # Read data from "image:"
    mov $image,%si
    cld
      # Read the first 16 bytes
    lodsw
nextLine:
      # Use bx as shift register
    mov %ax, %bx
      # Read the number of bombs
    mov 0x82,%dh
    sub $'0',%dh
nextBombInThisLine:
      # Number of characters
    mov $16, %cx
nextCharacter:
      # Rotate the data# get the next bit to CY
    rol $1, %bx
      # This results in 0x23 ('#') if CY is set, to 0x20 (' ') otherwise
    sbb %dl, %dl
    or $0x20, %dl
    and $0x23, %dl
      # Print result character twice
    mov $2, %ah
    int $0x21
    int $0x21
      # more Characters in this line?
    loop nextCharacter
      # More bombs to draw?
    dec %dh
    jnz nextBombInThisLine
      # Print a newline
#        mov $13, %dl # <- Additional 4 bytes needed for "\r\n"
#        int $0x21    #    at the end of the line!
    mov $10, %dl
    int $0x21
      # Read the next 16 bytes# 0x0000 means: EOF
    lodsw
    test %ax,%ax
    jnz nextLine
      # End of program
    int $0x20
image:
    # Here 34 bytes follow:
    # 16 16-bit-words "bitmap" for the bombs followed
    # by 0x0000 indicating the end of the bitmap

--- Editar ---

Olvidé mencionar: El programa debe iniciarse con la siguiente línea de comando:

Nombre del archivo COM + exactamente un carácter de espacio + Número de bombas (1-9)

Martin Rosenau
fuente
1
Agradable. Todavía nos falta una respuesta de 68000, pero esta se está acercando. :-)
Arnauld
objdump -dwLa salida es una buena manera de mostrar el binario sin formato, ya que puede ver qué bytes son qué instrucción. Lo hice para las respuestas de gcd y adler32 . (Además de incluir el código fuente comentado para que las personas se prueben a sí mismas)
Peter Cordes
8

Python, 223 179 bytes

Segundo enfoque:

f=lambda n:'\n'.join(''.join(2*' #'[int(d)]for d in bin(int('0c0052000100908023e003e00ff81ffc1ffc3ffe3fde1fdc1fbc0ff807f001c0'[i:i+4],16))[2:].zfill(16))*n for i in range(0,64,4))

Pruébalo en repl.it!

En lugar de crear una lista de cadenas sobre la marcha, hay una cadena hexadecimal codificada que se indexa y se convierte en binario; entonces cada dígito binario se convierte en ' 'o '#', que se duplica y se une ... etc.

Primer enfoque:

s='  ';b='##';f=lambda n:'\n'.join(n*l.ljust(32)for l in[s*4+b*2,(s+b)*2+s*2+b,s*7+b,b+s*2+b+s*4+b,s*2+b+s*3+b*5,s*6+b*5,s*4+b*9,s*3+b*11,s*3+b*11,s*2+b*13,s*2+b*8+s+b*4,s*3+b*7+s+b*3,s*3+b*6+s+b*4,s*4+b*9,s*5+b*7,s*7+b*3])

Pruébalo en repl.it!

Contiene una lista codificada de las cadenas de cada línea (sin incluir espacios finales) creadas por duplicación, ' 'o '##'varias veces. Para cada una de estas cadenas, se rellenan con espacios de hasta 32 caracteres de longitud, ntiempos duplicados , luego se unen con líneas nuevas.

Hactar
fuente
Puede guardar un byte cambiando a imprimir un generador desenrollado, en lugar de unirse '\n'. Por lo tanto, lambda n:print(*(''.join(2*' #'[int(d)]for d in bin(int('0c0052000100908023e003e00ff81ffc1ffc3ffe3fde1fdc1fbc0ff807f001c0'[i:i+4],16))[2:].zfill(16))*n for i in range(0,64,4))). Además, no tiene que contar los bytes necesarios para asignar un nombre a la lambda. Entonces su puntaje puede ser 176.
Morgan Thrapp
6

C, 250 240 208 188 bytes

d[]={3072,20992,256,36992,9184,992,4088,8188,8188,16382,16350,8156,8124,4088,2032,448,0},m,c,*i=d;f(k){for(;*i;i++,puts(""))for(c=k;c--;)for(m=32768;m;write(1,&"##  "[m&*i?0:2],2),m>>=1);}

Cambiar a usar una función.

m,d[]={3072,20992,256,36992,9184,992,4088,8188,8188,16382,16350,8156,8124,4088,2032,448,0},*i=d;main(c,v)char**v;{for(;*i;puts(""),i++)for(c=atoi(v[1]);c--;)for(m=32768;m;write(1,&"##  "[m&*i?0:2],2),m>>=1);}

Prueba así. main(c,v)char**v; { f(atoi(v[1])); } 

a.exe 2
        ####                            ####                        
  ##  ##    ##                    ##  ##    ##                  
              ##                              ##                    
##    ##        ##              ##    ##        ##              
    ##      ##########              ##      ##########          
            ##########                      ##########          
        ##################              ##################      
      ######################          ######################    
      ######################          ######################    
    ##########################      ##########################  
    ################  ########      ################  ########  
      ##############  ######          ##############  ######    
      ############  ########          ############  ########    
        ##################              ##################      
          ##############                  ##############        
              ######                          ######
cleblanc
fuente
Puede guardar algunos bytes utilizando las representaciones decimales de esos números hexadecimales para perder el 0x.
Cobre
@Copper Gracias, me las arreglé para recortar unos pocos bytes también usando escribir en lugar de putchar.
cleblanc
6

/// , 539 532 + no. de bytes de bombas

La primera /// respuesta, mostrando 4 bombas. Los últimos cuatro 1 pueden reemplazarse con cualquier representación unaria del número de bombas que desea imprimir (11 para 2, 111 para 3)

/-/?|X//y/\/X//xy|//|/\/\///+/%@!|$/bcd|%/efg|@/hij|!/klm|?/nop|b/Bxc/Cxd/Dxe/Exf/Fxg/Gxh/Hxi/Ixj/Jxk/Kxl/Lxm/Mxn/Nxo/Oxp/Pxq/ss|r/tt|s/SS|t/TT|S/  |T/##|1/AX$+-$+?AXyAX$+-cd+?by$+-d+?cycd+-+?dyd+-fg@!?ey+-g@!?fyfg@!-@!?gyg@!-ij!?hy@!-j!?iyij!-!?jyj!-lm?ky!-m?lylm-?mym-opny-poyop|AXA/AA|bB/BB|cC/CC|dD/DD|eE/EE|fF/FF|gG/GG|hH/HH|iI/II|jJ/JJ|kK/KK|lL/LL|mM/MM|nN/NN|oO/OO|pP/PP|A/qtqqs|B/STSTsTqqS|C/qsSTqq|D/TsTqTqsS|E/sTsSrTqS|F/qsrTqS|G/qrrTsS|H/sSrrtTs|I/sSrrtTs|J/srrrTS|K/srrSrS|L/sSrtTStTs|M/sSrtSrs|N/qrrTsS|O/qSrtTq|P/qsStTqs|X/
/1111

Pruébalo en línea!

Si la entrada debe ser decimal, lo siguiente tiene 555 548 bytes (donde el último dígito se puede cambiar a 1, 2, 3 o 4):

/-/?|X//y/\/X//xy|//|/\/\///4/13|3/12|2/11|^/tT|&/rr|*/sS|+/%@!|$/bcd|%/efg|@/hij|!/klm|?/nop|b/Bxc/Cxd/Dxe/Exf/Fxg/Gxh/Hxi/Ixj/Jxk/Kxl/Lxm/Mxn/Nxo/Oxp/Pxq/ss|r/tt|s/SS|t/TT|S/  |T/##|1/AX$+-$+?AXyAX$+-cd+?by$+-d+?cycd+-+?dyd+-fg@!?ey+-g@!?fyfg@!-@!?gyg@!-ij!?hy@!-j!?iyij!-!?jyj!-lm?ky!-m?lylm-?mym-opny-poyop|AXA/AA|bB/BB|cC/CC|dD/DD|eE/EE|fF/FF|gG/GG|hH/HH|iI/II|jJ/JJ|kK/KK|lL/LL|mM/MM|nN/NN|oO/OO|pP/PP|A/qtqqs|B/STSTsTqqS|C/q*Tqq|D/TsTqTq*|E/sT*rTqS|F/qsrTqS|G/q&T*|H/*&^s|I/*&^s|J/s&rTS|K/s&SrS|L/*r^S^s|M/*rtSrs|N/q&T*|O/qSr^q|P/q*^qs|X/
/4

Pruébalo en línea!

Las partes más importantes del código son que:
| significa //
ABCDEFGHIJKLMNOP significa cada línea de la bomba respectivamente
S significa 2 espacios
s significa 4 espacios
* significa 6 espacios
q significa 8 espacios
T
significa #### (4)
^ significa ##### # (6)
r significa ######## (8)
y significa ################ (16)
La mayor parte del código se asegura de que las bombas estén impresas lado a lado, no uno encima del otro.

boboquack
fuente
5

CJam , 66 bytes

"^a1{9\b aZ5w7qQAwndIUffO"136b2b1Ser0'#erG/ri*z{:_N}%

Pruébalo en línea! (tenga en cuenta que hay algunos caracteres no imprimibles en el código).

La bomba está codificada como un número en binario usando 1 para espacios (el espacio inicial como 1 asegura que no tengamos que rellenar las representaciones binarias), transpuesto y luego convertido a cadena en base-136 (que produjo la cadena más corta sin caracteres anchos). Estos pasos se pueden jugar aquí .

Esta respuesta invierte la codificación, el truco principal es repetir la bomba antes de transponer, concatenando efectivamente cada línea de la bomba a la vez. Los caracteres en cada línea se pueden duplicar con nuevas líneas insertadas para la salida final.

Linus
fuente
5

PHP, 138104 + 32 = 136 bytes

Nunca había pensado que fileera seguro binario. Solo desearía haber encontrado una forma más interesante de almacenar los datos; pero nada que probé venció al binario en bruto.

foreach(unpack("v*",file(b)[0])as$v)echo"
",str_repeat(strtr(sprintf("%016b",$v),["  ","##"]),$argv[1]);
  • leer datos binarios del archivo, descomprimir de little endian 16bit a array de int
  • recorrer la matriz: imprimir binario de 16 dígitos en una cadena, reemplazar 0con 2 espacios, 1con ##,
    repetir $argv[1]tiempos, imprimir resultado + nueva línea

corre con -r

datos binarios en el archivo b:

0000000 0c00 5200 0100 9080 23e0 03e0 0ff8 1ffc
0000010 1ffc 3ffe 3fde 1fdc 1fbc 0ff8 07f0 01c0

código para generar el archivo:

$f=fopen(b,wb);foreach(array_map(bindec,explode("
",
"0000110000000000
0101001000000000
0000000100000000
1001000010000000
0010001111100000
0000001111100000
0000111111111000
0001111111111100
0001111111111100
0011111111111110
0011111111011110
0001111111011100
0001111110111100
0000111111111000
0000011111110000
0000000111000000"))as$c)fputs($f,pack("v*",$c));fclose($f);
Titus
fuente
2
Puede guardar 2 bytes utilizando un salto de línea inicial en lugar de uno posterior y, por lo tanto, no tiene el espacio después del eco y utilizando un salto de línea real en lugar del \n.
user59178
@ user59178 Lo sé. no tan detallado por favor.
Titus
5

MATL , 64 63 60 59 58 bytes

49:',cxJr(v9hW&waHB`U=NL%)C9[$aoAN'F16ZaQEY"32e!' #'w)liX"

Pruébalo en línea!

Explicación

El código utiliza una versión precomprimida de la matriz binaria 16 × 16. La precompresión (que no forma parte del programa) utilizó dos pasos:

  1. Codificación de longitud de ejecución de la matriz leída en orden de fila mayor (primero a través, luego hacia abajo).
  2. Las longitudes de ejecución resultantes varían de 1 a 16, por lo que el vector de longitudes de ejecución menos 1 se convirtió de la base 16 a la base 94 (para usar todos los códigos ASCII imprimibles excepto la comilla simple, que no se usa porque necesitaría escapar).

La cuerda comprimida

   ',cxJr(v9hW&waHB`U=NL%)C9[$aoAN'

se descomprime de la base 94 a la base 16:

                                   F16Za

El vector obtenido de longitudes de carrera más 1 se multiplica por 2:

                                        QE

para realizar el estiramiento horizontal.

El vector de longitudes de carrera contiene 49 valores. Los números originales que se repetirán con esas longitudes deben ser [0 1 0 1 ... 0](49 entradas). Pero en lugar de eso, es más corto usar el vector [1 2 ... 49], que será igualmente válido gracias a la indexación modular. Entonces la decodificación de longitud de ejecución es

49:                                       Y"

El vector generado containis las carreras de 1, 2, ... 49, para un total de 512 entradas. Esto se reforma en una matriz de 16 × 32:

                                            32e!

y usado como índices modulares en la cadena ' #'para producir una sola bomba:

                                                ' #'w)

Finalmente, la repetición horizontal por un factor dado por la entrada produce el resultado deseado:

                                                      liX"
Luis Mendo
fuente
4

Python 2: 143 bytes

n=input()
j=2
while j<258:print''.join(2*'# '[b>'0']for b in bin(int('62XI2JG3U2Q0COCDFCZAMC8A9LAP6W1ZMM4A59GC43M49ENF3Z',36))[j:j+16])*n;j+=16

Esta en ideone

(Me di cuenta de que la codificación directa de la bomba original en la base 36 hacía un código más corto en Python).

La cadena se formó tratando los espacios como 1s y los hashes como 0s, y luego convirtiéndolos en la base 36. El programa luego vuelve a convertirlos en binarios y cortes en longitudes de 16 (con un desplazamiento de 2 para el '0b' en la parte delantera de Python) cadena binaria), se convierte en espacios dobles y hashes dobles, los une, repite los ntiempos de cadena e imprime.

Anterior: Python 2, 169 166 163 bytes

n=input()
j=0
while j<512:print''.join(' #'[i%2]*2*(v+1)for i,v in enumerate(int(c,16)for c in'31A00010F07010308024A4885A4A3C2703360245035876A25'))[j:j+32]*n;j+=32

Esta en ideone

Casi un puerto de mi respuesta Jelly .

Jonathan Allan
fuente
Ineficiente es bueno si es más corto. Niza +1
ElPedro
4

Python 2.7, 144 141 bytes

x=input()
for i in range(16):print"".join(" #"[b<"1"]*2for b in bin(int("5ZCAZKAVTP6J04W4VZJ2BQDH5DASIKRS524V8SWRSIVWZEWC8V",36))[2+i::16]*x)

La bomba está escrita en binario con 1 para el espacio, el 1 inicial elimina la necesidad de rellenar representaciones binarias. La bomba se transpone (al igual que en mi respuesta de CJam ) y se almacena en la base 36.

El programa decodifica la bomba en binario e itera bits en un paso de 16 siguiendo efectivamente la transposición (lo que ahorra bytes sobre el corte de una línea dada). La línea resultante se concatena, los bits se reemplazan por doblado o #, y se unen en una cadena singe.

Linus
fuente
1
Puede soltar el cero inicial de su número base 36.
Jonathan Allan
@ JonathanAllan: Buena captura. Pensé que era Opor alguna razón ...
Linus
4

C (gcc) , 216204183165134 bytes

b(n,i){for(n*=16,i=--n*16;i--;i%n||puts(""))printf(L"àϸ\x7fc\xfde\xfee`\x1fff\xffe\xffe\x7fcǰᇰ䡀\x80⤀\x600"[i/n]&1<<i%n%16?"##":"  ");}

Pruébalo en línea!

Escrito como un programa independiente ( 201183151 bytes)

i=16;main(j,l)char**l;{for(;i--;puts(""))for(j=*l[1]*16-769;j--;printf(L"àϸ\x7fc\xfde\xfee`\x1fff\xffe\xffe\x7fcǰᇰ䡀\x80⤀\x600"[i]&1<<j%16?"##":"  "));}

Pruébalo en línea!

Esto falla si no se proporciona un parámetro de línea de comando.

techo
fuente
3

Lote, 415 bytes.

@echo off
set h=#####
set s=
for %%a in ("    ##%s%%s%" " # #  #%s%    " "%s%  #%s%   " "#  #    #%s%  " "  #%h%%s%" "%s% %h%%s%" "    %h%####   " "   %h%%h%#  " "   %h%%h%#  " "  %h%%h%### " "  %h%### #### " "   %h%## ###  " "   %h%# ####  " "    %h%####   " "%s%%h%##    " "%s%  ###%s% ")do call:l %1 %%a
exit/b
:l
set r=
for /l %%i in (1,1,%1) do call set r=%%r%%%~2
set r=%r: =  %
echo %r:#=##%

Nota: la línea set s=termina en 5 espacios. Acepta el recuento como un parámetro de línea de comandos. Simplemente recorre cada línea de la bomba (comprimida muy ligeramente al eliminar series de 5 caracteres idénticos) y luego repite la bomba tantas veces como desee antes de finalmente duplicar cada personaje.

Neil
fuente
3

Python 2, 206 205 203 199 191 188 186 184 160 bytes

z=input()
for y in 3072,20992,256,36992,9184,992,4088,8188,8188,16382,16350,8156,8124,4088,2032,448:print"".join(" #"[e>0]*2for e in map(int,bin(y+8**6)[5:]))*z

Busqué en Hex la lista de números, pero no pareció ahorrar lo suficiente como para que valiera la pena. Esperaba poder descifrar el código pero parece que he llegado tan lejos como puedo con este enfoque. Cualquier pista adicional recibida con gratitud.

EDITAR

-1 cambiando e==1a e>0. Siempre me olvido de eso.

-2 ignorando la longitud de la cadena binaria, anteponiendo 7 0 y tomando solo los últimos 16 elementos. Funciona ya que nunca hay más de 7 ceros a la izquierda.

-4 porque ahora que he perdido la segunda referencia a la variable b, puedo usarla bin(y)[2:]directamente en la función de mapa llevándola debajo del magic 200 :-)

-8 usando la asignación de corte en la segunda lista. Aprendí algo nuevo esta noche.

-3 con gracias a @Jonathan

-2 usando en c=d=([0]*7+map(int,bin(y)[2:]))[-16:]lugar de tenerc=d;

-2 nuevamente gracias a @Jonathan

-24 gracias a @Linus

Salida

python bombs.py
2
        ####                            ####                    
  ##  ##    ##                    ##  ##    ##                  
              ##                              ##                
##    ##        ##              ##    ##        ##              
    ##      ##########              ##      ##########          
            ##########                      ##########          
        ##################              ##################      
      ######################          ######################    
      ######################          ######################    
    ##########################      ##########################  
    ################  ########      ################  ########  
      ##############  ######          ##############  ######    
      ############  ########          ############  ########    
        ##################              ##################      
          ##############                  ##############        
              ######                          ######
ElPedro
fuente
" #"[e>0]*2funcionará
Jonathan Allan
DOH! ¿Cómo extrañé esa? Gracias @ Jonathan
ElPedro
... los paréntesis (...)pueden ir también (RE: según mi comentario anterior).
Jonathan Allan
Puedes bajarlo a 170 confor y in ...:print"".join(" #"[e>0]*2for e in(([0]*7+map(int,bin(y)[2:]))[-16:]))*z
Jonathan Allan
@ Jonathan Gracias de nuevo. se está haciendo tarde aquí, así que guardaré ese cambio para mañana para no estropearlo por completo.
ElPedro
3

RProgN , 210 193 Bytes

Guarde algunos bytes cambiando 0 = '' 1 = '##' a 1 = '' 0 = '', esto significa que no necesito agregar los ceros adicionales. Además, esto significa que ahora la cadena B64 que solía decir "MAFIA" no lo hace, esto es triste.

'n' = => 64 -B 2 B ] 1 16 sub n rep \ 17 32 sub n rep '
' \ . . '1' '  ' replace '0' '##' replace } a'' = D4D/4/'' a DgQ/AH'' a DAIeAj'' a DgA8AB'' a DwB+AD'' a DcH/wf'' a D+/29/'' a Dz/63/'' a

Explicación

'n' =                   # Associate the input with "n"
=>                      # Push a new function to the stack.
    64 -B               # Take the value from the top of the stack, convert it to an integer from Base64
    2 B                 # Take the value from the top of the stack, convert it from an integer to binary
    ]                   # Duplicate the top of the stack.
    1 16 sub            # Push the substring from the top of the stack between 1 and 16, 1 indexed.
    n                   # Push the input.
    rep                 # Repeat, this gives us 'n' bombs, essentially.
    \                   # Flip the values such that REPEATEDBOMB_ROW TEXT
    17 32 sub           # Push the substring between 17 and 32.
    n                   # Push the input
    rep                 # Repeat
    '                   # Push a new line
'                       # RProgN doesn't actually have escapes, so the raw newline is represented as a newline between qoutes.
    \ . .               # Flip the values so we have LINE1 NEWLINE LINE2, then concatenate them all into one string.
    '1' '  ' replace    # Replace all the 1's in the binary string with two spaces.
    '0' '##' replace    # Replace all the 1's with two '#'s
} a'' =                 # Associate the function with 'a'
D4D/4/'' a              # Bottom two lines,
DgQ/AH'' a              # Next two up,
DAIeAj'' a              # Etc...
DgA8AB'' a              # Once This is done, the memory stack is implicitly printed from top to bottom.
DwB+AD'' a              # As such, the bomb is upside down.
DcH/wf'' a              # Each of these numbers represents two lines, which is why we do the substringing to split it.
D+/29/'' a              # This works out saving a few bytes.
Dz/63/'' a              # Implicitly printed output. Yay.

Bastante largo, la expansión, impresión y tal de la cadena comprimida es de 105 de los bytes. Podría ser un poco más golfable, pero al menos funciona.

La entrada está implícitamente en la pila, la pila se imprime implícitamente.

Salida

        ####                            ####                            ####                    
  ##  ##    ##                    ##  ##    ##                    ##  ##    ##                  
              ##                              ##                              ##                
##    ##        ##              ##    ##        ##              ##    ##        ##              
    ##      ##########              ##      ##########              ##      ##########          
            ##########                      ##########                      ##########          
        ##################              ##################              ##################      
      ######################          ######################          ######################    
      ######################          ######################          ######################    
    ##########################      ##########################      ##########################  
    ################  ########      ################  ########      ################  ########  
      ##############  ######          ##############  ######          ##############  ######    
      ############  ########          ############  ########          ############  ########    
        ##################              ##################              ##################      
          ##############                  ##############                  ##############        
              ######                          ######                          ######

¡Intentalo!

<style>
  #frame{
    width:60em;
    height:60em;
    border:none;
  }
</style>
<iframe id='frame' src="https://tehflamintaco.github.io/Reverse-Programmer-Notation/RProgN.html?rpn=%27n%27%20%3D%20%3D%3E%2064%20-B%202%20B%20%5D%201%2016%20sub%20n%20rep%20%5C%2017%2032%20sub%20n%20rep%20%27%0A%27%20%5C%20.%20.%20%271%27%20%27%20%20%27%20replace%20%270%27%20%27%23%23%27%20replace%20%7D%20a%27%27%20%3D%20D4D%2F4%2F%27%27%20a%20DgQ%2FAH%27%27%20a%20DAIeAj%27%27%20a%20DgA8AB%27%27%20a%20DwB%2BAD%27%27%20a%20DcH%2Fwf%27%27%20a%20D%2B%2F29%2F%27%27%20a%20Dz%2F63%2F%27%27%20a&input=1">Sorry, You need to support IFrame. Why don't you..?</iframe>
Expandir fragmento

Un taco
fuente
3

PHP, 144 140 139 138 136 bytes

Nota: utiliza la codificación de Windows-1252

for(;$j%=32*$argn or$r=intval(substr("01c02203k07d1j81j46b4cmwcmwpa4ohobugc8o6b434w0ow",$i++*3,3),36)*print~õ;)echo~ßÜ[$r>>$j++/2%16&1];

Corre así:

echo 2 | php -nR 'for(;$j%=32*$argn or$r=intval(substr("01c02203k07d1j81j46b4cmwcmwpa4ohobugc8o6b434w0ow",$i++*3,3),36)*print~õ;)echo~ßÜ[$r>>$j++/2%16&1];'

O utilizando la codificación IBM-850 (135 bytes y un resultado más bonito):

echo 2 | php -nR 'for(;$j%=32*$argn or$r=intval(substr(~¤╬£¤══¤╠ö¤╚ø╬òÃ╬ò╦╔Ø╦£Æê£ÆêÅ×╦ÉùÉØèÿ£ÃÉ╔Ø╦╠╦ê¤Éê,$i++*3,3),36)*print~§;)echo~▀M[$r>>$j++/2%16&1];'

        ▓▓▓▓                            ▓▓▓▓                    
  ▓▓  ▓▓    ▓▓                    ▓▓  ▓▓    ▓▓                  
              ▓▓                              ▓▓                
▓▓    ▓▓        ▓▓              ▓▓    ▓▓        ▓▓              
    ▓▓      ▓▓▓▓▓▓▓▓▓▓              ▓▓      ▓▓▓▓▓▓▓▓▓▓          
            ▓▓▓▓▓▓▓▓▓▓                      ▓▓▓▓▓▓▓▓▓▓          
        ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓              ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓      
      ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓          ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓    
      ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓          ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓    
    ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓      ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓  
    ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓  ▓▓▓▓▓▓▓▓      ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓  ▓▓▓▓▓▓▓▓  
      ▓▓▓▓▓▓▓▓▓▓▓▓▓▓  ▓▓▓▓▓▓          ▓▓▓▓▓▓▓▓▓▓▓▓▓▓  ▓▓▓▓▓▓    
      ▓▓▓▓▓▓▓▓▓▓▓▓  ▓▓▓▓▓▓▓▓          ▓▓▓▓▓▓▓▓▓▓▓▓  ▓▓▓▓▓▓▓▓    
        ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓              ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓      
          ▓▓▓▓▓▓▓▓▓▓▓▓▓▓                  ▓▓▓▓▓▓▓▓▓▓▓▓▓▓        
              ▓▓▓▓▓▓                          ▓▓▓▓▓▓

Explicación

Esto no hace nada binario y no requiere un archivo externo.

Cada número de 16 bits se invierte, luego se codifica como un número base 36, se rellena con un encabezado 0si es necesario, por lo que cada 16 bits da como resultado 3 bytes. Concatenando esos resultados en 01c02203k07d1j81j46b4cmwcmwpa4ohobugc8o6b434w0ow. El código invierte el proceso para que las bombas se impriman correctamente Nveces.

Ajustes

  • Guardado 4 bytes usando solo un bucle for
  • Se guardó un byte imprimiendo un único carácter para cada iteración y utilizando un índice de cadena en lugar de un ternario
  • Salvó un byte al restablecer $ja cero en los límites de línea con %=. Esto elimina los paréntesis
  • Guardado 2 bytes usando $argn
aross
fuente
3

GCC C 129 bytes

ISO8859 / ASCII

f(r,i,d){
    for(;i<32;i+=2,puts(""))
        for(d=15*r;--d;)
             printf((*(int*)&("ÿóÿ­ÿþoÜüðààÀ!ÀCÀCàðø?þ"[i]))&(1<<d%15)?"  ":"##");
}

En una linea:

f(r,i,d){for(;i<32;i+=2,puts(""))for(d=15*r;--d;)printf((*(int*)&("ÿóÿ­ÿþoÜüðààÀ!ÀCÀCàðø?þ"[i]))&(1<<d%15)?"  ":"##");}

Corre con:

main(c,v)char**v;{f(atoi(v[1]),0)}

Fuente de compilación como ISO8859-x (ASCII).

NB óÿÿþÿoÜüðààÀÀ! ÀCàCðøþ? debe contener los Códigos ASCII invisibles, pero se ha roto debido a la forma en que StackExchange presenta su contenido. Consulte el enlace de ideaone para una codificación de prueba adecuada. Alternativamente, la Cadena ASCII original se encuentra en: https://github.com/claydonkey/AtariBombs/blob/master/ISO8859_REPR2.txt

Explicación

Primero, una conversión de la representación hexadecimal de las bombas [f3 ff ad ff fe ff 6f 7f dc 1f fc 1f f0 07 e0 03 e0 03 c0 01 c0 21 c0 43 e0 43 f0 07 f8 0f fe 3f] a UTF-8 (en el En la versión UTF-8, el compilador almacena la cadena como Wide Char Array: 2 o 4 bytes para cada carácter en tiempo de ejecución, pero esto es académico). Mientras que los caracteres UTF-8 se almacenarían como 2-4 bytes, estos valores están todos dentro de ISO-8859-1 (ASCII) y, por lo tanto, solo requieren 1 byte. También es seguro almacenarlo como ISO-8859-x (no hay valores 0x8_ o 0x9_). Por lo tanto, el texto consume 32 bytes en ISO-8859 y la rutina consume 135 bytes en total.

(NB los caracteres anchos se almacenan como un entero de 16 bits en Windows y 32 bits en Linux, pero de nuevo esto es irrelevante para la tarea en cuestión)

Advertencia: no todos los caracteres se pueden mostrar (los caracteres de control por debajo de 0x20). Sin embargo, todavía están presentes. La mayoría de las páginas web son utf-8 / 8859/1253 ( https://w3techs.com/technologies/overview/character_encoding/all ), así que creo que esto es legítimo (cambiar todos los valores por debajo de 0x20 a ASCII imprimible debería solucionarlo).

UTF-8

Aquí está la versión más cercana a la publicación original con fuente codificada UTF-8. Esto consume 173 bytes. La cadena en sí es de 50 bytes de la fuente. La rutina también es más larga ya que los bytes ASCII ahora se almacenan con 0 de relleno para los caracteres anchos de 16 bits / 32 bits y deben cambiarse en lugar de convertirse a uint16_t como se indicó anteriormente. He mantenido esto, ya que se puede verificar con ideone, que utiliza la codificación UTF-8.

*w=L"óÿ­ÿþÿoÜüðààÀÀ!ÀCàCðøþ?";
f(r,i,j,m){
    for(i;i<32;i+=2,puts(""))
        for(j=r;j--;)
            for(m=65536;m>1;(m\=2,printf(((w[i]<<8)+w[i+1]&m)?"  ":"##")));}

Corre con:

main(c,v)char**v;{f(atoi(v[1]),0)}

Si puede establecer el valor implícito en un entero de 16 bits en su compilador, puede omitir la declaración de tipo wchar_t del Wide Char. Ideone no se queja, así que creo que es bueno ir.

Pruébalo en ideone

claydonkey
fuente
Impresionante. ¿Qué codificación usa esto?
DJMcMayhem
Está compilado en MinGW GCC donde un personaje ancho es un uint16. Por lo tanto, la codificación es [tipo de 16 bits con UTF-16 Unicode]. Sin embargo, creo que debido a que los caracteres están dentro de 0xFF (16 bits) se extienden ASCII. + Así que nada especial
claydonkey
Lo siento, he aprendido un poco más sobre la codificación y puede haber estado equivocado acerca de que se almacene como UTF-16, consulte la respuesta revisada.
claydonkey
2

Haskell, 155 bytes

Como una función con tipo Int -> String:

b z=concat$do y<-[0..15];"\n":[if odd$div 0x3800FE01FF03DF83BF87BFC7FFC3FF83FF81FF007C007C401090080004A0030(2^(16*y+x))then"##"else"  "|x<-[1..z]>>[0..15]]

Imprimir a IO directamente costará 5 bytes (o 6 si preferimos regresar en IO ()lugar de IO [()]):

b z=mapM putStr$do y<-[0..15];"\n":[if odd$div 0x3800FE01FF03DF83BF87BFC7FFC3FF83FF81FF007C007C401090080004A0030(2^(16*y+x))then"##"else"  "|x<-[1..z]>>[0..15]]
Nick Hansen
fuente
2

C, 175 bytes

 x[]={48,74,128,265,1988,1984,8176,16376,16376,32764,31740,15352,15864,8176,4064,896};f(z,p){while(z++<16){p=1;while(p<<=1){printf("%s",p&(x[z]<<16|x[z])?"##":" ");}puts("");}}

concatena cada x consigo mismo y hace que p se desborde para terminar cada línea.


fuente
Ah, cambié printf () para escribir cuando jugaba al golf y eso lo rompió. prueba aquí ideone.com/JtHInD
2

Java, 228 bytes

import static java.lang.System.out;

public class Bombs
{
    public static void main(String[] args)
    {
        new Bombs().d(2);
        new Bombs().d(3);
        new Bombs().d(4);
    }

    void d(int n){String s="";for(int x=16,r=0;r<16*n;x=16,s+=(++r%n==0?"\n":""))while(--x>=0)s+=((new int[]{1536,10496,128,18496,4592,496,2044,4094,4094,8191,8175,4078,4062,2044,1016,224}[r/n])&(1<<x))==0?"  ":"##";out.println(s);}

}
Marco13
fuente
1
Sé que ha pasado un año, pero puedes jugar a esto: n->{String s="";for(int x,r=0;r<16*n;s+=(++r%n<1?"\n":""))for(x=16;x-->0;)s+=((new int[]{1536,10496,128,18496,4592,496,2044,4094,4094,8191,8175,4078,4062,2044,1016,224}[r/n])&(1<<x))<1?" ":"##";return s;}( 205 bytes ) Además de usar un Java 8 lambda, he reducido más bytes cambiando: la posición de x=16(y cambiado whilea for); 2x ==0a <1; regresar en slugar de imprimirlo (las importaciones también son parte del byte-count por cierto ...); --x>=0a x-->0. Aún así, gran respuesta, entonces +1!
Kevin Cruijssen
@KevinCruijssen Gracias (considere publicar esto como una respuesta propia). No estoy tan activo aquí en codegolf, y por lo tanto no estoy seguro de las reglas, pero creo que en la mayoría de los casos, solo se permite contar los bytes de la función (e ignorar las importaciones).
Marco13
Es un poco demasiado similar para publicar como una respuesta separada, pero puedo entender si no desea editar su respuesta de hace más de un año. :) Solo lo dejaré en el comentario. Y me temo que las importaciones sí cuentan para el recuento de bytes.
Kevin Cruijssen
2

J, 89 bytes

|:@;@#&(<' #'{~2#|:16 16$}.2#.inv 95#.32x-~3 u:'u,:C>%}UwPXHn_C9wF.|U ap<{jH%O9 9wRThGs')

Codifica la cadena como un número base-95, incrementa cada dígito en 32, luego lo representa con una cadena ascii.

Explicación

Esto se compone de dos partes principales. Está la construcción de la bomba y la repetición real. Vamos a referirnos por el momento a la bomba como b. Entonces, el código se ve así:

|:@;@#&(b)

Cuando se llama con entrada k, esto es equivalente a:

|: ; (k#b)

bes una bomba en caja, por lo que k#bhace krepeticiones b, la ;aplana verticalmente y |:transpone el resultado. (La bomba en bsí está construida transpuesta).

Ahora, aquí está la bomba:

<' #'{~2#|:16 16$}.2#.inv 95#.32x-~3 u:'u,:C>%}UwPXHn_C9wF.|U ap<{jH%O9 9wRThGs'

La siguiente cadena es una cadena codificada en base 95 con un desplazamiento de 32, de modo que todos los caracteres caen en el rango ASCII, y afortunadamente no hay 's que necesiten escapar. 3 u:obtiene los códigos char de la cadena, 32x-~convierte cada número en un xnúmero tendido y lo resta 32; 95#.convierte a un número base 95 y lo 2#.invconvierte a una matriz de dígitos binarios. Agregué un encabezado 1al binario para que sea un número sólido, así que lo quito con }.. Moldeo la matriz en una tabla de 16x16 y 16 16$luego la transpongo usando |:. (Posible golf para más tarde: transponer la cadena codificada literal). 2#Duplica cada carácter a lo ancho. Nos queda una tabla de 0sy 1s.' #'{~mapas 0s a ' 'y 1a '#'. Por lo tanto, nos quedamos con nuestra bomba.

Caso de prueba

   |:@;@#&(<' #'{~2#|:16 16$}.2#.inv 95#.32x-~3 u:'u,:C>%}UwPXHn_C9wF.|U ap<{jH%O9 9wRThGs') 3
        ####                            ####                            ####
  ##  ##    ##                    ##  ##    ##                    ##  ##    ##
              ##                              ##                              ##
##    ##        ##              ##    ##        ##              ##    ##        ##
    ##      ##########              ##      ##########              ##      ##########
            ##########                      ##########                      ##########
        ##################              ##################              ##################
      ######################          ######################          ######################
      ######################          ######################          ######################
    ##########################      ##########################      ##########################
    ################  ########      ################  ########      ################  ########
      ##############  ######          ##############  ######          ##############  ######
      ############  ########          ############  ########          ############  ########
        ##################              ##################              ##################
          ##############                  ##############                  ##############
              ######                          ######                          ######
Conor O'Brien
fuente
2

BaCon , 229 227 195 bytes

Una contribución en BASIC en aras de la nostalgia. La variable 'a' determina la cantidad de bombas.

a=2:FOR x=0 TO 15:FOR y=1 TO a:FOR i=15 DOWNTO 0:?IIF$(v[x]&INT(POW(2,i)),"##","  ");:NEXT:NEXT:?:NEXT:LOCAL v[]={3072,20992,256,36992,9184,992,4088,8188,8188,16382,16350,8156,8124,4088,2032,448}

Salida :

        ####                            ####                    
  ##  ##    ##                    ##  ##    ##                  
              ##                              ##                
##    ##        ##              ##    ##        ##              
    ##      ##########              ##      ##########          
            ##########                      ##########          
        ##################              ##################      
      ######################          ######################    
      ######################          ######################    
    ##########################      ##########################  
    ################  ########      ################  ########  
      ##############  ######          ##############  ######    
      ############  ########          ############  ########    
        ##################              ##################      
          ##############                  ##############        
              ######                          ######
Peter
fuente
2

Haskell, 191 181 bytes

f n=h n:f(div n 2)
h n|odd n=' '
h _='#'
g b=mapM_ putStrLn[[f 0xfc7ff01fe00fc207c40784038003c007c007e00ff83ff83bfef6ff7fffb5ffcf!!(x`mod`32`div`2+y*16)|x<-[0..32*b-1]]|y<-[0..15]]
Angs
fuente
2

C (Atari TOS 2.06 US), 129124117113 bytes

short*a=0xe013b0;main(j,l)char**l;{for(;*a++-224;puts(""))for(j=*l[1]*16-768;j--;printf(*a&1<<j%16?"##":"  "));}

Esto utiliza el mapa de bits de la bomba de la ROM de TOS, que es ligeramente diferente del de la pregunta. Para otras versiones de TOS, deberá ajustar la dirección señalada por *a. ¡Tenga en cuenta que algunas roms de emulador no incluyen el mapa de bits de la bomba!

Si no proporciona un argumento de línea de comando, se pueden mostrar varias bombas de mapa de bits de alta resolución :-)

techo
fuente
1

C ++ 11, 252 bytes

#include <iostream>
using namespace std;string d("01c02203k07d1j81j46b4cmwcmwpa4ohobugc8o6b434w0ow");int main(){for(int i=0;i!=45;i+=3){int z=stoi(d.substr(i,3),NULL,36);for(unsigned long p=1;p!=1<<31;p<<=1){cout<<(((z<<16|z)&p)?"##":"  ");}puts("");}}

fuente
1

SmileBASIC, 127 bytes

INPUT N
FOR J=0TO 15FOR K=1TO N
FOR I=0TO 14?" #"[1AND ASC("xxxxxxxxxxxxxxx"[I])>>J]*2;
NEXT
NEXT?NEXT

captura de pantalla
(Captura de pantalla de la versión sin caracteres duplicados)
SB tiene una fuente cuadrada, por lo que duplicar los caracteres se ve mal (y no cabe en la pantalla)
Los caracteres no ASCII han sido reemplazados por x's.
Valores hexadecimales: 0008,0002,0610,1F8A,3FC1,7FC1,7FF2,FFF4,FFF8,EFF0,73F0,7FC0,3FC0,1F80,0600
dado que SB guarda archivos en UTF-8, algunos de estos cuentan como 2 o 3 bytes.

12Me21
fuente
@Arnauld No sé mucho acerca de SmileBASIC, pero teniendo en cuenta que hay un bucle FOR K=1TO Ncon INPUT N, creo que muestra el número de bombas que figuran en la entrada. Sin embargo, debo decir que a pesar de la fuente cuadrada, creo que los caracteres deben duplicarse para mantener la coherencia con los requisitos (para evitar una ventaja sobre otras respuestas). Podrías mantener la actual para una solución más atractiva, pero creo que aún debes agregar una solución correcta. Una vez que agregues eso, ¡votaré por el uso creativo de los caracteres UTF-8!
HyperNeutrino
@AlexL. Sí, mi comentario fue antes de la actualización del código.
Arnauld
1

Ruby 2.x (lambda) - 157 bytes

Probablemente se pueda jugar más, pero me gusta esta versión:

->n{puts "0c0052000100908023e003e00ff81ffc1ffc3ffe3fde1fdc1fbc0ff807f001c0".scan(/.{4}/).map{|x|(("%016b"%x.to_i(16)).tr("10","# ").chars.map{|c|c+c}*"")*n}}

Idea similar a la versión de Python (s): romper la cadena de bombas hexadecimal codificado en secciones de 4 caracteres, convertir a binario, se traduce 1a #y 0a , el doble de todos los personajes, e imprimir la matriz resultante.

Tenga en cuenta que Put se utiliza para imprimir la matriz. Esto imprimirá la matriz una línea por elemento.

Nerketur Kamachi
fuente
1

Excel VBA, 204 bytes

Función de ventana inmediata anónima VBE que toma la entrada del rango [A1]y las salidas al objeto ActiveSheet

Cells.RowHeight=48:For i=0To[A1-1]:[A4,B2,C5,D4,D2,E1:F1,G2,H3,I4,G5:K6,E7:M7,D8:N9,C10:J11,K10:O10,O11,L11:N13,K13:K15,L14:L15,M14,D12:I13,J12,E14:G14,F15:G15,H14:J16].Offset(,16*i).Interior.Color=0:Next

Salida

Babomb

Taylor Scott
fuente