Vamos desenhar algumas bombas Atari ST!

46

Introdução

O Atari ST era um computador pessoal bastante popular entre meados dos anos 80 e início dos anos 90, alimentado por um microprocessador Motorola 68000. Nesta máquina, o comportamento padrão do sistema operacional para exceções de CPU não capturadas era exibir uma linha de bombas na tela, conforme mostrado na figura a seguir:

fila de bombas

Fonte: https://commons.wikimedia.org/wiki/File:Row_of_bombs.png
Nota: Dependendo da versão do sistema operacional, os gráficos da bomba podem variar um pouco. Mas vamos tomar este como referência.

O número de bombas depende do vetor de exceção, sendo as mais comuns:

  • ($ 008) Erro de barramento: 2 bombas
  • ($ 00c) Erro de endereço: 3 bombas
  • ($ 010) Instrução ilegal: 4 bombas

Objetivo

Seu objetivo é escrever um programa ou função que imprima ou produza uma arte ASCII dessas bombas Atari ST.

Entrada

Um número inteiro que representa o número de bombas a serem exibidas. Seu código deve suportar os valores mais comuns: 2, 3 e 4. Suportar menos e / ou mais bombas é bom, mas não é necessário nem está sujeito a um bônus.

Resultado

A bomba original consiste em um bloco de 16x16 pixels, representado aqui em ASCII e binário:

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

Nesse desafio, cada bomba ASCII deve ser esticada até o dobro da largura original para obter uma melhor renderização. Portanto, ele consistirá em 16 linhas de 32 caracteres, usando ##pixels 'ON' e dois espaços para pixels 'OFF'. Todas as peças da bomba devem ser colocadas lado a lado. Espaços principais são proibidos. Espaços de fuga também são proibidos, exceto aqueles que realmente fazem parte do bloco de bombas (ou seja, as 31ª e 32ª colunas) que devem estar presentes. Você pode incluir não mais que uma quebra de linha inicial e não mais que uma quebra de linha final.

Exemplo

Abaixo está a saída de referência para duas bombas, em que as quebras de linha obrigatórias são marcadas como \ne as quebras de linha extras toleradas são marcadas como (\n):

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

(Obviamente, outros formatos de quebra de linha, como \rou também \r\npodem ser usados.)

Regras

Isso é código-golfe, então a resposta mais curta em bytes vence. As brechas padrão são proibidas.

code-golf  ascii-art  kolmogorov-complexity 
— Arnauld
fonte
Percebo que você excluiu formas não artísticas ASCII, portanto, uma função de código de máquina Atari ST que trava com o número certo de bombas não conta. (A bomba não está na fonte, mas o Atari ST possui glifos divertidos / de ovos de páscoa em seu conjunto de caracteres nativos, incluindo os caracteres 28-31, que são quatro peças que formam a imagem de JR "Bob" Dobbs da igreja satírica do SubGenius lembro-me de escrever um programa que spam aqueles 4 glifos em posições de tela aleatórios, como um exercício muito cedo usando chamadas de sistema de desenho de texto :).
— Peter Cordes
1
@ PeterCordes - Isso mesmo, deve ser ASCII. No entanto, você poderá ler os gráficos da bomba na ST ROM, pois não existe uma regra que o impeça de fazê-lo. (Basta mencionar a versão TOS isto é suposto para trabalhar.)
— Arnauld
1
Oh WOW, isso traz de volta memórias. Meu primeiro computador foi um Atari ST. Lembro-me daquelas bombas com pavor.
— Rod
Lado: "O número de bombas depende do vetor de exceção" - diga o que ?! Alguma razão pela qual eles não puderam gerar o código / erro real? (Nunca teve uma ST, eu sou do campo Amiga ... "Guru Meditação" e tudo isso.)
— MrWhite

Respostas:

20

Geléia , 43 44 bytes

+1 byte - esqueceu de dobrar os caracteres (não que alguém tenha notado!)

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

TryItOnline

Quão?

A preparação foi compactar os dados como uma codificação de execução da imagem original:

  • Conte o comprimento de cada execução de 1s (espaço) ou 0s (hash) na imagem, ignorando novas linhas - produz uma lista [4,2,11,1,1,...]:;
  • Subtraia um de cada número - isso fornece um intervalo de [0,15];
  • Trate isso como um número de base 16 (enumere os valores v,, com o índice iao contrário e some 16**i*v= 19468823747267181273462257760938030726282593096816512166437);
  • Converta isso em base-250 [5,119,249,42,...]:;
  • Mapeie na página de código do Jelly como índices: ¥vẏ)X;ndĊɓ¡ẹ3ċi}Ịɲ¡P

Agora, o código avalia esse número, mapeia 1s e 0s para caracteres de espaço e hash *, dobra cada um, divide-se em linhas e repete cada um o número apropriado de vezes.
* na verdade, a implementação é realizada no módulo 2 para salvar bytes, portanto os espaços são ímpares e os hashes são 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
fonte
19

05AB1E , 57 55 53 50 bytes

Usa a codificação CP-1252 .

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

Experimente online!

Explicação

Como a imagem de saída consiste apenas de 2 caracteres, podemos representá-la como um número binário.
Podemos ignorar novas linhas, pois todas as linhas têm o mesmo comprimento.
Podemos ignorar o último caractere de cada linha, da mesma forma para todas as linhas.
Usamos a imagem mais fina, pois ocupa menos espaço e podemos duplicar facilmente cada caractere posteriormente.

Usando 1 para representar espaço e 0 para representar # , obtemos o número binário:

111100111111111101011011111111111111101111111011011110111111110111000001111111111000001111111100000000011111000000000001111000000000001110000000000000110000000010000111000000010001111000000100001111100000000011111110000000111111111100011111

Em seguida, convertemos isso em base 10 e depois o compactamos na base 214, a base máxima em 05AB1E. O resultado disso é:

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

A carne do programa consiste no seguinte:

<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
fonte
12

Pitão, 57 56 54 53 51 50 bytes

O código contém caracteres não imprimíveis, então aqui está um xxdhexdump reversível .

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

Experimente online.

— PurkkaKoodari
fonte
11

JavaScript (ES6), 159 154 140 136 bytes

Economizou muitos bytes graças a @Hedi e @Arnauld

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

São 104 caracteres, mas (infelizmente) 136 bytes UTF-8. A sequência foi gerada com este trecho:

Mostrar snippet de código

Usar em .replacevez de [...string].mapé igualmente longo:

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

Como funciona

Como cada linha dos dados brutos pode ser representada como um número de 16 bits, podemos armazenar o arquivo inteiro em uma sequência de 16 caracteres. O algoritmo de compactação pega cada linha binária, a inverte e a inverte (uma vez que toda linha no original termina em 0 , toda linha na versão modificada agora começa com 1 ), depois a transforma em char e concatena os caracteres resultantes .

Para descompactá-lo, precisamos extrair o código e transformar sua representação binária em uma cadeia de hashes e espaços. Isso pode ser feito com uma função recursiva, da seguinte maneira:

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

fpega repetidamente o último bit de q, selecionando dois espaços se for 1 ou dois hashes se for 0 e concatena isso com o resultado da execução fno restante de q. Isso é executado x.charCodeAt(), transformando o código de caractere na sequência correta de espaços e hashes.

(Havia muito mais drama aqui antes, mas a técnica de economia de 4 bytes apagou tudo isso.)

Depois disso, podemos apenas repetir os ntempos das strings e adicionar uma nova linha. Este é o método mais curto de descompressão que encontrei, mas fique à vontade para sugerir métodos possivelmente mais curtos.

Outras tentativas de compactar a sequência:

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`
`

O primeiro deles tem 153 bytes, portanto, nenhum deles chega perto de 136 ...

— ETHproductions
fonte
Poderia salvar alguns bytes com em +x?'##':' 'vez de" #"[x].repeat(2)
— Hedi 03/10
@ Hedi obrigado, eu sabia que havia uma maneira de jogar golfe.
— ETHproductions
2
Você poderia testar diretamente os bits em x.charCodeAt()vez de convertê-los em binários? (Acho que pouparia cerca de 8 bytes.)
— Arnauld
2
Seu algoritmo de compactação parece quase criptográfico .
— Justin
1
@ Justin Droga, eu estava prestes a comentar isso.
— user253751
10

Arquivo .com do MS-DOS, 84 bytes

ESTÁ BEM. Só por diversão, porque não consigo vencer os 50 bytes ...

Tentei no DOSbox e no MS-DOS 6.22 em uma máquina virtual.

No DOSbox, o programa funciona bem; no entanto, no MS-DOS real, a saída não será exibida corretamente porque o DOS requer CR-LF em vez de LF no final da linha.

(No entanto, a saída está correta.)

Uma variante de 88 bytes usaria CR-LF no final da linha.

Aqui está o arquivo:

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

O código do assembler (na sintaxe da AT&T) fica assim:

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 ---

Esqueci de mencionar: O programa deve ser iniciado com a seguinte linha de comando:

Nome do arquivo COM + exatamente um caractere de espaço + Número de bombas (1-9)

— Martin Rosenau
fonte
1
Agradável. Ainda não temos uma resposta 68000, mas esta está se aproximando. :-)
— Arnauld 4/16
objdump -dwA saída é uma boa maneira de mostrar o binário bruto, desde que você veja quais bytes são quais instruções. Eu fiz isso para as respostas gcd e adler32 . (Bem como incluindo o código fonte comentou que as pessoas tentem se.)
— Peter Cordes
8

Python, 223 179 bytes

Segunda abordagem:

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

Experimente em repl.it!

Em vez de criar uma lista de strings on-the-fly, há uma string hexadecimal codificada que é indexada e convertida em binária; então cada dígito binário é transformado em um ' 'ou '#', que é duplicado e unido ... etc.

Primeira abordagem:

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

Experimente em repl.it!

Ele contém uma lista codificada das seqüências de caracteres de cada linha (sem incluir espaços à direita) criadas duplicando uma ' 'ou '##'várias vezes. Para cada uma dessas cadeias de caracteres, elas são preenchidas com espaços até 32 caracteres, duplicados nvezes e, em seguida, unidas a novas linhas.

— Hactar
fonte
Você pode salvar um byte, alternando para imprimir um gerador desenrolado, em vez de entrar '\n'. Então 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))),. Além disso, você não precisa contar os bytes necessários para atribuir um nome ao lambda. Então, sua pontuação pode 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);}

Mude para o uso de uma função.

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

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

a.exe 2
        ####                            ####                        
  ##  ##    ##                    ##  ##    ##                  
              ##                              ##                    
##    ##        ##              ##    ##        ##              
    ##      ##########              ##      ##########          
            ##########                      ##########          
        ##################              ##################      
      ######################          ######################    
      ######################          ######################    
    ##########################      ##########################  
    ################  ########      ################  ########  
      ##############  ######          ##############  ######    
      ############  ########          ############  ########    
        ##################              ##################      
          ##############                  ##############        
              ######                          ######
— cleblanc
fonte
Você pode salvar alguns bytes usando as representações decimais desses números hexadecimais para perder o 0x.
— Copper
@ Copper Obrigado, eu consegui raspar alguns bytes também usando write no lugar de putchar.
— Cleblanc 4/10
6

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

A primeira /// resposta, exibindo 4 bombas. Os quatro primeiros 1s podem ser substituídos por qualquer representação unária do número de bombas que você deseja 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

Experimente online!

Se a entrada precisar ser decimal, o seguinte possui 555 548 bytes (onde o último dígito pode ser alterado para 1, 2, 3 ou 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

Experimente online!

As partes mais importantes do código são as seguintes:
| significa //
ABCDEFGHIJKLMNOP significa cada linha da bomba, respectivamente
S significa 2 espaços
s significa 4 espaços
* significa 6 espaços
q significa 8 espaços
T significa ## (2)
t significa #### (4)
^ significa ##### # (6)
r significa ######## (8)
e significa ################ (16)
A maior parte do código é garantir que as bombas sejam impressas lado a lado, não um em cima do outro.

— boboquack
fonte
5

CJam , 66 bytes

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

Experimente online! (observe que existem alguns caracteres não imprimíveis no código.)

A bomba é codificada como um número no binário usando 1 para espaços (o espaço inicial como 1 garante que não tenhamos que preencher as representações binárias), transposta e depois convertida em string na base-136 (que produziu a string mais curta sem caracteres largos). Estes passos podem ser executados aqui .

Essa resposta inverte a codificação, o principal truque é repetir a bomba antes da transposição, concatenando efetivamente cada linha da bomba de uma só vez. Os caracteres em cada linha podem ser dobrados com novas linhas inseridas para a saída final.

— Linus
fonte
5

PHP, 138 104 + 32 = 136 bytes

Eu nunca pensei que isso filefosse binário seguro. Eu só gostaria de ter encontrado uma maneira mais interessante de armazenar os dados; mas nada que eu tentei vencer binário bruto.

foreach(unpack("v*",file(b)[0])as$v)echo"
",str_repeat(strtr(sprintf("%016b",$v),["  ","##"]),$argv[1]);
  • ler dados binários do arquivo, descompactar de little endian 16bit para array de int
  • loop pela matriz: imprime 16 dígitos binários em string, substitua 0por 2 espaços, 1por ##,
    repetir $argv[1]tempos, imprimir resultado + nova linha

correr com -r

dados binários no arquivo b:

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

código para gerar o arquivo:

$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
fonte
2
Você pode salvar 2 bytes usando uma quebra de linha inicial em vez de à direita e, portanto, não tendo espaço após o eco e usando uma quebra de linha real em vez de \n.
— user59178
@ user59178 eu sei. não é tão detalhado, por favor.
— Titus
5

MATL , 64 63 60 59 58 bytes

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

Experimente online!

Explicação

O código usa uma versão pré-compactada da matriz binária 16 × 16. A pré-compactação (que não faz parte do programa) usou duas etapas:

  1. A codificação de comprimento de execução da matriz é lida na ordem das linhas principais (primeiro através e depois abaixo).
  2. Os comprimentos de execução resultantes variam de 1 a 16, portanto, o vetor de comprimentos menos 1 foi convertido da base 16 para a base 94 (para usar todos os códigos ASCII imprimíveis, exceto as aspas simples, que não são usadas porque precisariam de escape).

A cadeia compactada,

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

é descompactado da base 94 para a base 16:

                                   F16Za

O vetor obtido dos tempos de execução mais 1 é multiplicado por 2:

                                        QE

para realizar o alongamento horizontal.

O vetor de comprimento de execução contém 49 valores. Os números originais a serem repetidos com esses comprimentos devem ser [0 1 0 1 ... 0](49 entradas). Mas, em vez disso, é mais curto usar o vetor [1 2 ... 49], que será igualmente válido graças à indexação modular. Portanto, a decodificação de execução é

49:                                       Y"

O vector gerado containis as corridas de 1, 2, ... 49, para um total de 512 entradas. Isso é remodelado em uma matriz 16 × 32:

                                            32e!

e usado como índices modulares na cadeia ' #'para produzir uma única bomba:

                                                ' #'w)

Finalmente, a repetição horizontal por um fator fornecido pela entrada produz o resultado desejado:

                                                      liX"
— Luis Mendo
fonte
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

Está no ideone

(Eu percebi que a codificação direta da bomba original na base 36 fazia com que o código fosse mais curto em Python.)

A string foi formada tratando espaços como 1s e hashes como 0s e depois convertendo para a base 36. O programa então converte novamente em binário e fatias em comprimentos de 16 (com um deslocamento de 2 para o '0b' na frente do Python. string binária), converte em espaços duplos e hashes duplos, junta-os, repete os ntempos da string 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

Está no ideone

Quase um porto da minha resposta Jelly .

— Jonathan Allan
fonte
Ineficiente é bom se for mais curto. Agradável +1
— ElPedro 04/04
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)

A bomba é escrita em binário com 1 para espaço, o primeiro 1 elimina a necessidade de preencher representações binárias. A bomba é transposta (como na minha resposta CJam ) e armazenada na base 36.

O programa decodifica a bomba para binária e itera bits em uma etapa de 16 efetivamente após a transposição (que economiza bytes ao cortar uma determinada linha). A linha resultante é concatenada, os bits são substituídos por duplicado ou #e unidos em uma cadeia de caracteres simples.

— Linus
fonte
1
Você pode eliminar o zero inicial do seu número base 36.
— Jonathan Allan
@ JonathanAllan: Boa captura. Eu pensei que era um Opor alguma razão ...
— Linus
4

C (gcc) , 216 204 183 183 134 134 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?"##":"  ");}

Experimente online!

Escrito como um programa independente ( 201 183 151 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?"##":"  "));}

Experimente online!

Isso ocorre se um parâmetro da linha de comandos não for fornecido.

— teto
fonte
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: a linha set s=termina em 5 espaços. Aceita a contagem como um parâmetro de linha de comando. Simplesmente percorre cada linha da bomba (compactada levemente removendo séries de 5 caracteres idênticos) e repete a bomba quantas vezes desejar antes de finalmente duplicar cada caractere.

— Neil
fonte
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

Olhou para Hex a lista de números, mas não pareceu economizar o suficiente para fazer valer a pena o esforço. Esperava poder aplicar o código, mas parece ter chegado o mais longe possível com essa abordagem. Quaisquer dicas adicionais recebidas com gratidão.

EDITAR

-1 alterando e==1para e>0. Eu sempre esqueço esse.

-2 ignorando o comprimento da cadeia binária, acrescentando 7 0 e obtendo apenas os últimos 16 elementos. Funciona como nunca há mais de 7 0s principais.

-4 porque agora que perdi a segunda referência à variável b, posso usá-la bin(y)[2:]diretamente na função map, levando-a abaixo da mágica 200 :-)

-8 usando a atribuição de fatia na segunda lista. Aprendi algo novo esta noite.

-3 com agradecimentos a @ Jonathan

-2 usando em c=d=([0]*7+map(int,bin(y)[2:]))[-16:]vez de terc=d;

-2 novamente graças a @Jonathan

-24 com agradecimentos a @Linus

Resultado

python bombs.py
2
        ####                            ####                    
  ##  ##    ##                    ##  ##    ##                  
              ##                              ##                
##    ##        ##              ##    ##        ##              
    ##      ##########              ##      ##########          
            ##########                      ##########          
        ##################              ##################      
      ######################          ######################    
      ######################          ######################    
    ##########################      ##########################  
    ################  ########      ################  ########  
      ##############  ######          ##############  ######    
      ############  ########          ############  ########    
        ##################              ##################      
          ##############                  ##############        
              ######                          ######
— ElPedro
fonte
" #"[e>0]*2vai funcionar
— Jonathan Allan
DOH! Como eu senti falta dessa ??? Obrigado @ Jonathan
— ElPedro
... os parênteses também (...)podem ir (RE: por meu comentário anterior).
— Jonathan Allan
Você pode reduzi-lo a 170 com #for y in ...:print"".join(" #"[e>0]*2for e in(([0]*7+map(int,bin(y)[2:]))[-16:]))*z
— Jonathan Allan
@ Jonathan Obrigado novamente. está ficando tarde aqui, então vou guardar essa mudança para amanhã, para não estragar tudo.
— ElPedro 4/10
3

RProgN , 210 193 bytes

Salvei alguns bytes alternando 0 = '' 1 = '##' para 1 = '' 0 = '', isso significa que não preciso adicionar os zeros extras de volta. Além disso, isso significa que agora a string B64 que costumava dizer "MAFIA" não, isso é 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

Explicação

'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 longo, a expansão, a impressão e a sequência compactada são 105 dos bytes. Pode ser um pouco mais jogável, mas pelo menos funciona.

A entrada está implicitamente na pilha, a pilha é implicitamente impressa.

Resultado

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

Tente!

<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 snippet

— ATaco
fonte
3

PHP, 144 140 139 138 136 bytes

Nota: usa codificação Windows-1252

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

Execute assim:

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

Ou usando a codificação IBM-850 (135 bytes e resultado mais 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];'

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

Explicação

Isso não faz nada binário e não requer um arquivo externo.

Cada número de 16 bits é revertido e, em seguida, codificado como um número de base 36, preenchido com um avanço, 0se necessário, portanto, a cada 16 bits resulta em 3 bytes. Concatenando esses resultados em 01c02203k07d1j81j46b4cmwcmwpa4ohobugc8o6b434w0ow. O código inverte o processo para que as bombas sejam impressas corretamente na Nhora.

Tweaks

  • 4 bytes salvos usando apenas um único loop for
  • Salva um byte imprimindo um único caractere para cada iteração e usando o índice de string em vez de ternário
  • Salva um byte, redefinindo $jpara zero nos limites da linha com %=. Isso se livra dos parênteses
  • 2 bytes salvos usando $argn
— aross
fonte
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)?"  ":"##");
}

Em uma linha:

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

Correr com:

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

Compile a origem como ISO8859-x (ASCII).

NB óÿÿþÿoÜüðààÀ! ÀCàCðøþ? deve conter os códigos ASCII invisíveis, mas foi quebrado devido à maneira como o StackExchange apresenta seu conteúdo. Consulte o link ideaone para obter a codificação de teste adequada. Alternativamente, a string ASCII original está em: https://github.com/claydonkey/AtariBombs/blob/master/ISO8859_REPR2.txt

Explicação

Primeiro, uma conversão da representação hexadecimal de 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] para UTF-8 (no Na versão UTF-8, o compilador armazena a sequência como Wide Char Array - 2 ou 4 bytes para cada caractere em tempo de execução, mas isso é acadêmico). Enquanto os caracteres UTF-8 seriam armazenados como 2-4 bytes, esses valores estão todos dentro da ISO-8859-1 (ASCII) e, portanto, requerem apenas 1 byte. Também é seguro ser armazenado como ISO-8859-x (não há valores 0x8_ ou 0x9_). Portanto, o texto consome 32 bytes na ISO-8859 e a rotina consome 135 bytes no total.

(Caracteres de largura NB são armazenados como um número inteiro de 16 bits no Windows e 32 bits no Linux, mas novamente isso é irrelevante para a tarefa em questão)

Advertência: Nem todos os caracteres são exibidos (os caracteres de controle abaixo de 0x20). Eles ainda estão presentes. A maioria das páginas da web é utf-8 / 8859/1253 ( https://w3techs.com/technologies/overview/character_encoding/all ), então acho que isso é legítimo (mudar todos os valores abaixo de 0x20 para ASCII imprimível deve corrigir isso).

UTF-8

Aqui está a versão mais próxima da postagem original com fonte codificada em UTF-8. Isso consome 173 bytes. A string em si é de 50 bytes da fonte. A rotina também é mais longa, já que os bytes ASCII agora são armazenados com zeros de preenchimento para os Wide Chars de 16 bits / 32 bits e precisam ser alterados em vez de convertidos para uint16_t como acima. Eu mantive isso, pois pode ser verificado com ideona que usa codificação 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)?"  ":"##")));}

Correr com:

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

Se você pode definir o valor implícito como um número inteiro de 16 bits no complier, pode omitir a declaração do tipo wchar_t do Wide Char. Ideone não reclama, então eu acho que é bom ir.

Experimente em ideone

— claydonkey
fonte
Impressionante. Que codificação isso usa?
— DJMcMayhem
É compilado no MinGW GCC, onde um caractere amplo é um uint16. Portanto, a codificação é [tipo de 16 bits que contém UTF-16 Unicode]. No entanto, acho que, como os caracteres estão dentro de 0xFF (16 bits), eles são estendidos ASCII. + Portanto, nada de especial
— claydonkey 7/16
Desculpe, eu aprendi um pouco mais sobre a codificação e pode estar errado sobre ela ser armazenada como UTF-16.Por favor, consulte a resposta revisada.
— Claydonkey # 14/16
2

Haskell, 155 bytes

Como uma função com o 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 diretamente no IO custará 5 bytes (ou 6, se preferirmos retornar em IO ()vez 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
fonte
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 para si próprio e faz p exceder o limite para terminar cada linha.

ah, mudei printf () para escrever quando jogava golfe, e isso quebrou. teste aqui 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
fonte
1
Sei que já faz um ano, mas você pode fazer o seguinte: 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 ) Além de usar um Java 8 lambda, reduzi mais bytes alterando: a posição do x=16(e alterei whilepara for); 2x ==0a <1; retornando em svez de imprimi-lo (as importações também fazem parte da contagem de bytes). --x>=0para x-->0. Ainda assim, ótima resposta, então +1!
— Kevin Cruijssen
@KevinCruijssen Obrigado (considere postar isso como uma resposta pessoal). Eu não sou tão ativo aqui no codegolf, e, portanto, não tenho certeza sobre as regras, mas acho que, na maioria dos casos, apenas é permitido contar os bytes da função (e ignorar as importações).
— precisa saber é o seguinte
É um pouco parecido com a postagem como resposta separada, mas entendo se você não deseja editar sua resposta há mais de um ano. :) Vou deixar no comentário. E receio que as importações realmente sejam consideradas na contagem 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 a string como um número base-95, incrementa cada dígito por e 32, em seguida, representa-a por uma string ascii.

Explicação

Isso é composto de duas partes principais. Há a construção da bomba e a repetição real. Por enquanto, vamos nos referir à bomba como b. Em seguida, o código se parece com:

|:@;@#&(b)

Quando chamado com entrada k, isso é equivalente a:

|: ; (k#b)

bé uma bomba in a box, então k#bfaz krepetições b, ;achata verticalmente e |:transpõe o resultado. (A bprópria bomba é construída transposta.)

Agora, aqui está a bomba:

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

A sequência a seguir é uma sequência codificada na base 95 com um deslocamento de 32, para que todos os caracteres caiam no intervalo ASCII e, felizmente, não há 's que precisem ser escapados. 3 u:obtém os códigos de caracteres da string, 32x-~torna cada número um xnúmero desejado e subtrai 32dele; 95#.converte em um número base-95 e 2#.invconverte-o em uma matriz de dígitos binários. Eu adicionei um líder 1ao binário para torná-lo um número sólido, então eu o tiro com ele }.. Eu moldo a matriz em uma tabela 16x16 16 16$e a transponho usando |:. (Possível golfe para mais tarde: transponha a string literal codificada.) 2#Duplica cada caractere na largura. Ficamos com uma tabela de 0s e 1s.' #'{~mapeia 0s para ' 'e 1para '#'. Assim, ficamos com nossa bomba.

Caso de teste

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

Bacon , 229 227 195 bytes

Uma contribuição no BASIC por uma questão de nostalgia. A variável 'a' determina a quantidade 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}

Saída :

        ####                            ####                    
  ##  ##    ##                    ##  ##    ##                  
              ##                              ##                
##    ##        ##              ##    ##        ##              
    ##      ##########              ##      ##########          
            ##########                      ##########          
        ##################              ##################      
      ######################          ######################    
      ######################          ######################    
    ##########################      ##########################  
    ################  ########      ################  ########  
      ##############  ######          ##############  ######    
      ############  ########          ############  ########    
        ##################              ##################      
          ##############                  ##############        
              ######                          ######
— Peter
fonte
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
fonte
2

C (Atari TOS 2.06 US), 129 124 117 113 113 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?"##":"  "));}

Isso usa o bitmap de bomba da ROM do TOS, que é um pouco diferente do da pergunta. Para outras versões do TOS, será necessário ajustar o endereço indicado por *a. Observe que algumas ROMs de emulador não incluem o bitmap da bomba!

Se você não fornecer um argumento de linha de comando, várias bombas de bitmap mapeadas de alta resolução podem ser exibidas :-)

— teto
fonte
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("");}}
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 tela
(Captura de tela da versão sem caracteres duplicados) O
SB possui uma fonte quadrada, portanto, a duplicação dos caracteres parece ruim (e não cabe na tela)
Os caracteres não ASCII foram substituídos por x's.
Valores hexadecimais: 0008,0002,0610,1F8A,3FC1,7FC1,7FF2,FFF4,FFF8,EFF0,73F0,7FC0,3FC0,1F80,0600
como o SB salva arquivos em UTF-8, alguns deles contam como 2 ou 3 bytes.

— 12Me21
fonte
@Arnauld Eu não sei muito sobre SmileBASIC, mas dado que não há um laço FOR K=1TO Ncom INPUT N, eu acho que exibe o número de bombas fornecidas na entrada. No entanto, devo dizer que, apesar da fonte quadrada, acredito que os caracteres ainda devem ser dobrados para manter a consistência com os requisitos (para evitar uma vantagem sobre outras respostas). Você pode manter a atual para obter uma solução mais agradável, mas acho que você ainda deve adicionar uma solução correta. Depois de adicionar isso, votarei pelo uso criativo dos caracteres UTF-8!
— HyperNeutrino
@AlexL. Sim, meu comentário foi anterior à atualização do código.
— Arnauld
1

Ruby 2.x (lambda) - 157 bytes

Provavelmente pode ser jogado ainda mais, mas eu gosto desta versão:

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

Idéia semelhante à da (s) versão (ões) do python: divida a sequência de bombas codificadas hexadecimais em seções de 4 caracteres, converta em binário, traduza 1para #e 0para , dobre cada caractere e imprima a matriz resultante.

Observe que o put é usado para imprimir a matriz. Isso imprimirá a matriz uma linha por elemento.

— Nerketur Kamachi
fonte
1

Excel VBA, 204 bytes

Função de janela imediata VBE anônima que leva a entrada do intervalo [A1]e as saídas para o 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

Resultado

Babomb

— Taylor Scott
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.