Wprowadzenie

Atari ST był dość popularny komputer osobisty od połowy lat 80-tych do początku lat 90-era, zasilany przez Motorola 68000 mikroprocesor. Na tym komputerze domyślnym zachowaniem systemu operacyjnego w przypadku nieprzechwyconych wyjątków procesora było wyświetlanie rzędu bomb na ekranie, jak pokazano na poniższym obrazku:

_{Źródło: https://commons.wikimedia.org/wiki/File:Row_of_bombs.png
Uwaga: W zależności od wersji systemu operacyjnego grafika bomby może się nieznacznie różnić. Ale weźmy to jako odniesienie.}

Liczba bomb zależy od wektora wyjątku, z których najczęstszymi są:

• (008 $) Błąd autobusu: 2 bomby
• (00c $) Błąd adresu: 3 bomby
• (010 USD) Nielegalna instrukcja: 4 bomby

Cel

Twoim celem jest napisanie programu lub funkcji, która drukuje lub generuje sztukę ASCII takich bomb Atari ST.

Wejście

Liczba całkowita reprezentująca liczbę bomb do wyświetlenia. Twój kod musi obsługiwać najczęstsze wartości: 2, 3 i 4. Wspieranie mniejszej i / lub większej liczby bomb jest w porządku, ale nie jest ani wymagane, ani nie podlega premii.

Wynik

Oryginalna bomba składa się z kafelka 16 x 16 pikseli, reprezentowanego tutaj zarówno w ASCII, jak i binarnie:

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

W tym wyzwaniu każda bomba ASCII musi zostać rozciągnięta do dwukrotności swojej pierwotnej szerokości w celu lepszego renderowania. Dlatego będzie się składał z 16 wierszy po 32 znaki, przy użyciu ##pikseli „ON” i dwóch spacji dla pikseli „OFF”. Wszystkie płytki bombowe muszą być ułożone obok siebie. Wiodące miejsca są zabronione. Końcowe spacje są również zabronione, z wyjątkiem tych, które faktycznie są częścią płytki bomby (tj. 31. i 32. kolumna), które muszą być obecne. Możesz dołączyć nie więcej niż jeden wiodący podział linii i nie więcej niż jeden końcowy podział linii.

Przykład

Poniżej przedstawiono dane wyjściowe dla dwóch bomb, w których obowiązkowe przerwy w linii są oznaczone jako, \na tolerowane dodatkowe przerwy w linii są oznaczone jako (\n):

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

(Oczywiście inne formaty podziału linii, takie jak \rlub, \r\nmogą być również używane).

Zasady

To jest golf golfowy, więc wygrywa najkrótsza odpowiedź w bajtach. Standardowe luki są zabronione.

Galaretka , 43 44 bajty

+1 bajt - zapomniałem podwoić znaki (nie żeby nikt tego nie zauważył!)

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

TryItOnline

W jaki sposób?

Przygotowanie miało na celu skompresowanie danych jako kodowanie całego obrazu oryginalnego:

• Policz długość każdego przebiegu 1s (spacja) lub 0s (skrót) na obrazie, ignorując nowe linie - daje listę [4,2,11,1,1,...]:;
• Odejmij jeden od każdej liczby - daje to zakres [0,15];
• Traktuj to jako liczbę podstawową 16 (wylicz wartości v, z indeksem iw odwrotnej kolejności i zsumuj 16**i*v= 19468823747267181273462257760938030726282593096816512166437);
• Konwertuj to na base-250 [5,119,249,42,...]:;
• Odwzoruj na stronie kodowej Jelly jako indeksy: ¥vẏ)X;ndĊɓ¡ẹ3ċi}Ịɲ¡P

Teraz kod ocenia tę liczbę, mapuje 1s i 0s do spacji i znaków skrótu *, podwaja każdy z nich, dzieli się na linie i powtarza każdą odpowiednią liczbę razy.
* faktycznie implementacja jest wykonywana modulo 2 w celu zapisania bajtów, więc spacje są nieparzyste, a hasze są parzyste:

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

05AB1E , 57 55 53 50 bajtów

Wykorzystuje kodowanie CP-1252 .

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

Wypróbuj online!

Wyjaśnienie

Ponieważ obraz wyjściowy składa się tylko z 2 znaków, możemy go przedstawić jako liczbę binarną.
Możemy zignorować znaki nowej linii, ponieważ każda linia ma tę samą długość.
Możemy zignorować ostatni znak każdego wiersza, ponieważ jest taki sam dla wszystkich wierszy.
Używamy cieńszego obrazu, ponieważ zajmuje on mniej miejsca i możemy z łatwością powielić każdą postać później.

Używając 1 do reprezentowania spacji i 0 do reprezentowania # otrzymujemy liczbę binarną:

111100111111111101011011111111111111101111111011011110111111110111000001111111111000001111111100000000011111000000000001111000000000001110000000000000110000000010000111000000010001111000000100001111100000000011111110000000111111111100011111

Następnie przekształcamy to w base-10, a następnie kompresujemy do base 214, maksymalnej bazy w 05AB1E. Wynikiem tego jest:

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

Mięso programu składa się z następujących elementów:

<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

Pyth, 57 56 54 53 51 50 bajtów

Kod zawiera znaki niedrukowalne, więc oto odwracalny xxdzrzut heksowy.

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

Wypróbuj online.

JavaScript (ES6), 159 154 140 136 bajtów

Zaoszczędzono wiele bajtów dzięki @Hedi i @Arnauld

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

To 104 znaki, ale (niestety) 136 bajtów UTF-8. Ciąg został wygenerowany za pomocą tego fragmentu:

console.log([
0b1111111111001111,
0b1111111110110101,
0b1111111101111111,
0b1111111011110110,
0b1111100000111011,
0b1111100000111111,
0b1110000000001111,
0b1100000000000111,
0b1100000000000111,
0b1000000000000011,
0b1000010000000011,
0b1100010000000111,
0b1100001000000111,
0b1110000000001111,
0b1111000000011111,
0b1111110001111111
].map(x=>(65535-x).toString(16)).join(","))

Używanie .replacezamiast [...string].mapjest równie długie:

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

Jak to działa

Ponieważ każdy wiersz nieprzetworzonych danych może być reprezentowany jako 16-bitowa liczba, możemy zapisać cały plik w ciągu 16 znaków. Algorytm kompresji zajmuje każdy wiersz binarny, odwraca ją i odwraca go (od każdego wiersza w oryginalnym kończy się w 0 , każdy wiersz w wersji zmodyfikowanej teraz rozpoczyna się z 1 ), a następnie zamienia ją w char, a Łączy wynikających znaków .

Aby go zdekompresować, musimy wyodrębnić kod znaków i przekształcić jego reprezentację binarną w ciąg skrótów i spacji. Można to zrobić za pomocą funkcji rekurencyjnej, na przykład:

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

fwielokrotnie bierze ostatni bit q, wybierając dwie spacje, jeśli jest to 1 lub dwa hasze, jeśli wynosi 0, a następnie łączy to z wynikiem działania fw pozostałej części q. Jest to uruchamiane x.charCodeAt(), zamieniając kod znakowy na prawidłowy ciąg spacji i skrótów.

(Wcześniej było o wiele więcej dramatu, ale technika oszczędzania 4 bajtów usunęła to wszystko.)

Następnie możemy po prostu powtórzyć ciąg znaków ni dodać nowy wiersz. Jest to najkrótsza metoda dekompresyjna, jaką znalazłem, ale możesz zaproponować wszelkie możliwie krótsze metody.

Inne próby kompresji ciągu:

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

Pierwszy z nich ma 153 bajty, więc żaden z nich nie zbliża się do 136 ...

Plik MS-DOS .COM, 84 bajty

DOBRZE. Tylko dla zabawy, bo nie mogę pobić 50 bajtów ...

Próbowałem pod DOSbox, a także pod MS-DOS 6.22 na maszynie wirtualnej.

W DOSboksie program działa dobrze, jednak w prawdziwym MS-DOS dane wyjściowe nie będą wyświetlane poprawnie, ponieważ DOS wymaga CR-LF zamiast LF na końcu linii.

(Jednak dane wyjściowe są prawidłowe.)

Wariant 88-bajtowy używałby CR-LF na końcu linii.

Oto plik:

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

Kod asemblera (w składni AT&T) wygląda następująco:

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

--- Edytować ---

Zapomniałem wspomnieć: Program należy uruchomić za pomocą następującego wiersza polecenia:

Nazwa pliku COM + dokładnie jeden znak spacji + Liczba bomb (1-9)

Python, 223 179 bajtów

Drugie podejście:

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

Wypróbuj na repl.it!

Zamiast tworzyć listę ciągów w locie, istnieje zakodowany na stałe ciąg szesnastkowy, który jest indeksowany i konwertowany na binarny; następnie każda cyfra binarna jest zamieniana na jedną ' 'lub '#', która jest duplikowana i łączona razem ... itd.

Pierwsze podejście:

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

Wypróbuj na repl.it!

Zawiera ona zakodowaną listę ciągów każdego wiersza (nie wliczając spacji końcowych) utworzonych przez duplikowanie jednego ' 'lub '##'kilku razy. Dla każdego z tych ciągów są one wypełniane spacjami do długości 32 znaków, nrazy zduplikowane , a następnie łączone nowymi liniami.

C, 250 240 208 188 bajtów

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

Przejdź do korzystania z funkcji.

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

Testuj w ten sposób. main(c,v)char**v; { f(atoi(v[1])); }

a.exe 2
        ####                            ####                        
  ##  ##    ##                    ##  ##    ##                  
              ##                              ##                    
##    ##        ##              ##    ##        ##              
    ##      ##########              ##      ##########          
            ##########                      ##########          
        ##################              ##################      
      ######################          ######################    
      ######################          ######################    
    ##########################      ##########################  
    ################  ########      ################  ########  
      ##############  ######          ##############  ######    
      ############  ########          ############  ########    
        ##################              ##################      
          ##############                  ##############        
              ######                          ######            

/// , 539 532 + nie. bajtów bomb

Pierwsza odpowiedź ///, wyświetlająca 4 bomby. Końcowe cztery 1 można zastąpić dowolną reprezentacją liczby bomb, które chcesz wydrukować (11 za 2, 111 za 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

Wypróbuj online!

Jeśli dane wejściowe muszą być dziesiętne, następujący kod ma 555 548 bajtów (gdzie ostatnią cyfrę można zmienić na 1, 2, 3 lub 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

Wypróbuj online!

Najważniejszą części kodu są następujące:
| oznacza //
ABCDEFGHIJKLMNOP oznacza odpowiednio każdą linię bomby
S oznacza 2 spacje
s oznacza 4 spacje
* oznacza 6 spacji
q oznacza 8 spacji
T oznacza ## (2)
t oznacza #### (4)
^ oznacza ##### # (6)
r oznacza ######## (8)
i oznacza ################ (16)
Większość kodu upewnia się, że bomby są wydrukowane obok siebie, a nie jedna na drugiej.

CJam , 66 bajtów

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

Wypróbuj online! (zwróć uwagę, że w kodzie jest kilka znaków niedrukowalnych).

Bomba jest zakodowana jako liczba binarna za pomocą 1 dla spacji (spacja wiodąca jako 1 gwarantuje, że nie musimy wypełniać reprezentacji binarnych), transponowana, a następnie przekształcona w ciąg w bazie 136 (co dało najkrótszy ciąg bez szerokich znaków). Kroki te mogą być odtwarzane z tutaj .

Ta odpowiedź następnie odwraca kodowanie, a główną sztuczką jest powtórzenie bomby przed transpozycją, skutecznie łącząc każdą linię bomby na raz. Znaki w każdym wierszu można następnie podwoić, wstawiając nowe wiersze dla ostatecznego wyniku.

PHP, 138 104 + 32 = 136 bajtów

Nigdy nie myślałem, że fileto binarnie bezpieczne. Chciałbym tylko znaleźć bardziej interesujący sposób przechowywania danych; ale nic nie próbowałem pokonać surowego pliku binarnego.

foreach(unpack("v*",file(b)[0])as$v)echo"
",str_repeat(strtr(sprintf("%016b",$v),["  ","##"]),$argv[1]);

• wczytaj dane binarne z pliku, rozpakuj od małego endianu 16bit do tablicy int
• zapętlaj tablicę: wypisz 16 cyfr binarnych na ciąg, zamień na 02 spacje, 1z ##,
  powtórz $argv[1]czasy, wydrukuj wynik + nowa linia

Biegnij z -r

dane binarne w pliku b:

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

kod do wygenerowania pliku:

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

MATL , 64 63 60 59 58 bajtów

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

Wypróbuj online!

Wyjaśnienie

Kod wykorzystuje wstępnie skompresowaną wersję macierzy binarnej 16 × 16. Wstępne kompresowanie (nie jest częścią programu) składało się z dwóch etapów:

1. Kodowanie przez całą długość matrycy odczytywanej w kolejności według rzędów (najpierw w poprzek, potem w dół).
2. Wynikowe długości przebiegów mieszczą się w zakresie od 1 do 16, więc wektor długości przebiegów minus 1 został przekonwertowany z podstawy 16 na podstawę 94 (aby użyć wszystkich drukowalnych kodów ASCII z wyjątkiem pojedynczego cudzysłowu, który nie jest używany, ponieważ wymagałby ucieczki).

Skompresowany ciąg znaków,

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

jest dekompresowany z bazy 94 do bazy 16:

                                   F16Za

Otrzymany wektor długości przebiegu plus 1 jest mnożony przez 2:

                                        QE

wykonać rozciąganie w poziomie.

Wektor przebiegów zawiera 49 wartości. Pierwotne liczby, które należy powtórzyć dla tych długości, powinny wynosić [0 1 0 1 ... 0](49 wpisów). Ale zamiast tego krótsze jest użycie wektora [1 2 ... 49], który będzie równie ważny dzięki modułowemu indeksowaniu. Tak więc dekodowanie długości przebiegu jest

49:                                       Y"

Wygenerowany wektor containis te przebiegi 1, 2... 49, w sumie 512 zgłoszeń. Przekształca się to w matrycę 16 × 32:

                                            32e!

i użyte jako modułowe indeksy w sznurku ' #'do wytworzenia jednej bomby:

                                                ' #'w)

Wreszcie, powtarzanie w poziomie przez współczynnik podany przez dane wejściowe daje pożądany rezultat:

                                                      liX"

Python 2: 143 bajty

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

Jest w ideone

(Zdałem sobie sprawę, że bezpośrednie kodowanie oryginalnej bomby w bazie 36 stworzyło krótszy kod w Pythonie).

Ciąg został utworzony przez traktowanie spacji jako 1s, a skrótów jako 0, a następnie konwersję do bazy 36. Następnie program konwertuje z powrotem na binarny i kroi na długości 16 (z przesunięciem 2 dla „0b” z przodu Pythona ciąg binarny), konwertuje na podwójne spacje i podwójne skróty, łączy je, powtarza nczasy ciągów i drukuje.

Poprzedni: Python 2, 169 166 163 bajtów

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

Jest w ideone

Prawie port mojej galaretki .

Python 2.7, 144 141 bajtów

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

Bomba jest zapisana dwójkowo z 1 dla spacji, wiodąca 1 eliminuje potrzebę wypełniania reprezentacji binarnych. Bomba jest transponowana (podobnie jak w mojej odpowiedzi CJam ) i przechowywana w bazie 36.

Program dekoduje bombę na dane binarne i iteruje bity o krok 16 efektywnie po transpozycji (co oszczędza bajty przed pocięciem danej linii). Powstała linia jest konkatenowana, bity są zastępowane podwójnymi lub #i łączone w pojedynczy ciąg.

C (gcc) , 216 204 183 165 134 bajtów

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?"##":"  ");}

Wypróbuj online!

Napisany jako samodzielny program ( 201 183 151 bajtów)

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?"##":"  "));}

Wypróbuj online!

Powoduje to awarię, jeśli nie podano parametru wiersza polecenia.

Partia, 415 bajtów

@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:#=##%

Uwaga: linia set s=kończy się 5 spacjami. Akceptuje liczbę jako parametr wiersza polecenia. Po prostu zapętla się przez każdą linię bomby (bardzo lekko ściśnięta przez usunięcie serii 5 identycznych znaków), a następnie powtarza bombę tyle razy, ile jest to pożądane, zanim ostatecznie powiela każdą postać.

Python 2, 206 205 203 199 191 188 186 184 160 bajtów

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

Spojrzałem na Hex na listę numerów, ale nie wydawało się, by oszczędzało wystarczająco dużo, aby było warte wysiłku. Miałem nadzieję, że uda mi się zagrać w golfa w dół, ale wydaje mi się, że udało mi się osiągnąć tak daleko, jak to możliwe dzięki temu podejściu. Wszelkie dodatkowe wskazówki z wdzięcznością otrzymane.

EDYTOWAĆ

-1, zmieniając e==1na e>0. Zawsze o tym zapominam.

-2, ignorując długość ciągu binarnego, poprzedzając 7 0 i biorąc tylko ostatnie 16 elementów. Działa, ponieważ nigdy nie ma więcej niż 7 wiodących zer.

-4, ponieważ teraz, gdy straciłem drugie odniesienie do zmiennej b, mogę użyć bin(y)[2:]bezpośrednio w funkcji mapy, biorąc ją poniżej magicznej 200 :-)

-8 za pomocą przypisania plasterków na drugiej liście. Nauczyłem się dziś czegoś nowego.

-3 dzięki dzięki @Jonathan

-2 przy użyciu c=d=([0]*7+map(int,bin(y)[2:]))[-16:]zamiastc=d;

-2 ponownie dzięki @Jonathan

-24 dzięki dzięki @Linus

Wynik

python bombs.py
2
        ####                            ####                    
  ##  ##    ##                    ##  ##    ##                  
              ##                              ##                
##    ##        ##              ##    ##        ##              
    ##      ##########              ##      ##########          
            ##########                      ##########          
        ##################              ##################      
      ######################          ######################    
      ######################          ######################    
    ##########################      ##########################  
    ################  ########      ################  ########  
      ##############  ######          ##############  ######    
      ############  ########          ############  ########    
        ##################              ##################      
          ##############                  ##############        
              ######                          ######  

RProgN , 210 193 bajtów

Zapisano niektóre bajty, zmieniając 0 = '' 1 = '##' na 1 = '' 0 = '', co oznacza, że ​​nie muszę dodawać dodatkowych zer. Oznacza to również, że teraz ciąg B64, który zwykł mówić „MAFIA”, nie jest smutny.

'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

Wyjaśnienie

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

Dość długi, rozszerzenie, drukowanie i taki skompresowany ciąg ma 105 bajtów. Może być nieco bardziej golfowy, ale przynajmniej działa.

Dane wejściowe są domyślnie na stosie, stos jest domyślnie drukowany.

Wynik

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

Spróbuj!

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

PHP, 144 140 139 138 136 bajtów

Uwaga: używa kodowania Windows-1252

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

Uruchom tak:

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

Lub używając kodowania IBM-850 (135 bajtów i ładniejszy wynik):

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

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

Wyjaśnienie

Nie robi to żadnych binarnych rzeczy i nie wymaga zewnętrznego pliku.

Każda 16-bitowa liczba jest odwracana, a następnie kodowana jako liczba podstawowa 36, ​​w 0razie potrzeby dopełniana wiodącym , więc co 16 bitów daje 3 bajty. Łączenie tych wyników w 01c02203k07d1j81j46b4cmwcmwpa4ohobugc8o6b434w0ow. Kod odwraca proces, więc bomby są drukowane poprawnie Nrazy.

Poprawki

• Zaoszczędzono 4 bajty, używając tylko jednej pętli for
• Zapisano bajt, drukując pojedynczy znak dla każdej iteracji i używając indeksu łańcuchowego zamiast trójskładnikowego
• Zapisano bajt poprzez resetowanie $jdo zera na granicach linii za pomocą %=. Pozbywa się to nawiasów
• Zaoszczędzono 2 bajty $argn

GCC C 129 bajtów

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)?"  ":"##");
}

W jednej linii:

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

Biegnij z:

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

Skompiluj źródło jako ISO8859-x (ASCII).

NB óÿÿþÿoÜüðààÀÀ! ÀCàCðøþ? powinien zawierać niewidoczne kody ASCII, ale został uszkodzony z powodu sposobu, w jaki StackExchange prezentuje swoją zawartość. Link do ideone do prawidłowego kodowania testowego można znaleźć alternatywnie Oryginalny ciąg ASCII znajduje się pod adresem : https://github.com/claydonkey/AtariBombs/blob/master/ISO8859_REPR2.txt

Wyjaśnienie

Najpierw konwersja reprezentacji szesnastkowej bomb [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] na UTF-8 (w Wersja UTF-8 kompilator przechowuje ciąg znaków jako Wide Char Array - 2 lub 4 bajty dla każdego znaku w czasie wykonywania, ale ma to charakter akademicki. Podczas gdy znaki UTF-8 byłyby przechowywane jako 2-4 bajty, wszystkie te wartości mieszczą się w ISO-8859-1 (ASCII), a zatem wymagają tylko 1 bajtu. Można również bezpiecznie przechowywać jako ISO-8859-x (nie ma wartości 0x8_ lub 0x9_). Dlatego tekst zużywa 32 bajty w ISO-8859, a procedura zużywa łącznie 135 bajtów.

(NB szerokie znaki są przechowywane jako 16-bitowa liczba całkowita w systemie Windows i 32-bitowa w systemie Linux, ale znowu nie ma to znaczenia dla wykonywanego zadania)

Uwaga: Nie wszystkie znaki są wyświetlane (znaki kontrolne poniżej 0x20). Są one jednak obecne. Większość stron internetowych to utf-8 / 8859/1253 ( https://w3techs.com/technologies/overview/character_encoding/all ), więc uważam, że jest to uzasadnione (przesunięcie wszystkich wartości poniżej 0x20 na ASCII do wydruku powinno to naprawić).

UTF-8

Oto wersja bliższa oryginalnemu wpisowi ze źródłem kodowanym w UTF-8. To zużywa 173 bajtów. Sam łańcuch jest 50 bajtami źródła. Procedura jest również dłuższa, ponieważ bajty ASCII są teraz przechowywane z dopełnianiem zer dla 16-bitowych / 32-bitowych znaków szerokich i należy je przesunąć zamiast rzutować na uint16_t jak wyżej. Tak utrzymywałem, ponieważ można to zweryfikować za pomocą ideonu, który wykorzystuje kodowanie 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)?"  ":"##")));}

Biegnij z:

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

Jeśli możesz ustawić wartość domyślną na 16-bitową liczbę całkowitą w swoim kompilatorze, możesz pominąć deklarację typu wchar_t dla Wide Char. Ideone nie narzeka, więc uważam, że warto iść.

Wypróbuj na ideone

Haskell, 155 bajtów

W funkcji typu 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]]

Bezpośrednie drukowanie do IO będzie kosztowało 5 bajtów (lub 6, jeśli wolimy zwracać IO ()niż 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]]

C, 175 bajtów

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

konkatenuje każdy x do siebie i powoduje przepełnienie p, aby zakończyć każdą linię.

Java, 228 bajtów

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

}

J, 89 bajtów

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

Koduje ciąg jako liczbę podstawową 95, zwiększa każdą cyfrę o 32, a następnie reprezentuje ją jako ciąg ascii.

Wyjaśnienie

Składa się z dwóch głównych części. Istnieje konstrukcja bomby i faktyczne powtórzenie. Na razie określmy bombę jako b. Następnie kod wygląda następująco:

|:@;@#&(b)

Po wywołaniu z wejściem kodpowiada to:

|: ; (k#b)

bjest bombą w pudełku, więc k#bwykonuje kpowtórzenia b, ;spłaszcza ją pionowo i |:transponuje wynik. (Sama bomba bjest transponowana).

Oto bomba:

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

Poniższy ciąg jest ciągiem zakodowanym w formacie base-95 z przesunięciem 32, dzięki czemu wszystkie znaki mieszczą się w zakresie ASCII i na szczęście nie ma żadnych znaków 'ucieczki. 3 u:pobiera kody znaków ciągu, 32x-~czyni każdą liczbę rozszerzoną xi odejmuje 32od niej; 95#.konwertuje na liczbę podstawową 95 i 2#.invkonwertuje ją na tablicę cyfr binarnych. Dodałem interlinię 1do pliku binarnego, aby stała się liczbą całkowitą, więc go zdejmuję }.. Kształtuję tablicę w stół 16x16, a 16 16$następnie transponuję ją za pomocą |:. (Możliwy golf na później: transponuj dosłownie zakodowany ciąg znaków.) 2#Powielają każdy znak pod względem szerokości. Pozostaje nam tabela 0s i 1s.' #'{~mapy 0s do ' 'i 1do '#'. W ten sposób zostaje nam nasza bomba.

Przypadek testowy

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

BaCon , 229 227 195 bajtów

Wkład w BASIC dla nostalgii. Zmienna „a” określa liczbę bomb.

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}

Wyjście :

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

Haskell, 191 181 bajtów

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

C (Atari TOS 2.06 US), 129 124 117 113 bajtów

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

Używa to mapy bitowej bomb z TOS ROM, która nieco różni się od tej w pytaniu. W przypadku innych wersji TOS musisz dostosować adres wskazany przez *a. Zauważ, że niektóre romy emulatorów nie zawierają mapy bitowej bomb!

Jeśli nie podasz argumentu wiersza poleceń, może zostać wyświetlonych kilka bomb bitmapowych o wysokiej rozdzielczości :-)

C ++ 11, 252 bajtów

#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("");}}

SmileBASIC, 127 bajtów

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

(Zrzut ekranu wersji bez podwojonych znaków)
SB ma kwadratową czcionkę, więc podwojenie znaków wygląda źle (i nie mieści się na ekranie)
Znaki spoza ASCII zostały zastąpione przez x.
Wartości szesnastkowe: 0008,0002,0610,1F8A,3FC1,7FC1,7FF2,FFF4,FFF8,EFF0,73F0,7FC0,3FC0,1F80,0600
Ponieważ SB zapisuje pliki w UTF-8, niektóre z nich liczą się jako 2 lub 3 bajty.

Ruby 2.x (lambda) - 157 bajtów

Prawdopodobnie można grać w golfa dalej, ale podoba mi się ta wersja:

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

Podobny pomysł jak w wersji (wersjach) Pythona: rozbić ciąg szesnastkowo kodowanych bomb na sekcje po 4 znaki, przekonwertować na binarne, tłumaczyć 1na #i 0na , podwoić każdy znak i wydrukować wynikową tablicę.

Zauważ, że put służy do wydrukowania tablicy. Spowoduje to wydrukowanie tablicy po jednej linii na element.

Excel VBA, 204 bajty

Anonimowa funkcja okna natychmiastowego VBE, która pobiera dane wejściowe z zakresu [A1]i dane wyjściowe do obiektu 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

Wynik