Mari kita menggambar beberapa bom Atari ST!

46

pengantar

The Atari ST adalah komputer pribadi agak populer dari pertengahan 80-an hingga awal era 90-an, didukung oleh Motorola 68000 mikroprosesor. Pada mesin ini, perilaku default sistem operasi untuk pengecualian CPU yang tidak tertangkap adalah menampilkan deretan bom di layar, seperti yang ditunjukkan pada gambar berikut:

deretan bom

Sumber: https://commons.wikimedia.org/wiki/File:Row_of_bombs.png
NB: Tergantung pada versi OS, grafik bom mungkin sedikit berbeda. Tapi mari kita ambil yang ini sebagai referensi.

Jumlah bom tergantung pada vektor pengecualian, yang paling umum adalah:

  • ($ 008) Kesalahan Bus: 2 bom
  • ($ 00c) Kesalahan Alamat: 3 bom
  • ($ 010) Instruksi Ilegal: 4 bom

Tujuan

Tujuan Anda adalah untuk menulis program atau fungsi yang mencetak atau mengeluarkan seni ASCII dari bom Atari ST tersebut.

Memasukkan

Integer yang mewakili jumlah bom untuk ditampilkan. Kode Anda harus mendukung nilai-nilai yang paling umum: 2, 3 dan 4. Mendukung lebih sedikit dan / atau lebih banyak bom baik-baik saja, tetapi tidak diperlukan atau dikenai bonus.

Keluaran

Bom asli terdiri dari ubin 16x16 piksel, diwakili di sini dalam ASCII dan biner:

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

Dalam tantangan ini, setiap bom ASCII harus direntangkan menjadi dua kali lebar aslinya untuk rendering yang lebih baik. Oleh karena itu, itu akan terdiri dari 16 baris 32 karakter, menggunakan ##untuk piksel 'ON' dan dua spasi untuk piksel 'OFF'. Semua ubin bom harus diletakkan berdampingan. Ruang terkemuka dilarang. Ruang trailing juga dilarang, kecuali ruang yang sebenarnya merupakan bagian dari ubin bom (yaitu kolom ke-31 dan ke-32) yang harus ada. Anda dapat memasukkan tidak lebih dari satu break-line terdepan dan tidak lebih dari satu break-line trailing.

Contoh

Di bawah ini adalah keluaran referensi untuk dua bom, di mana pemutusan saluran wajib ditandai sebagai \ndan pemutusan saluran tambahan yang ditandai ditandai sebagai (\n):

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

(Tentu saja, format break-line lainnya seperti \ratau \r\ndapat digunakan juga.)

Aturan

Ini adalah kode-golf, jadi jawaban tersingkat dalam byte menang. Celah standar dilarang.

code-golf  ascii-art  kolmogorov-complexity 
— Arnauld
sumber
Saya perhatikan Anda telah mengecualikan bentuk non-ASCII-art, jadi fungsi kode mesin Atari ST yang mogok dengan jumlah bom yang tepat tidak masuk hitungan. (Bom tidak ada di dalam font, tetapi Atari ST memiliki mesin terbang yang menyenangkan / paskah dengan karakter aslinya, termasuk karakter 28–31 yang terdiri dari 4 bagian yang membentuk gambar JR "Bob" Dobbs dari Gereja satiris. dari SubGenius . Saya ingat menulis sebuah program yang mem-spammed 4 mesin itu pada posisi layar acak, sebagai latihan yang sangat awal dalam menggunakan panggilan sistem menggambar teks :)
— Peter Cordes
1
@PeterCordes - Benar, itu pasti ASCII. Namun, Anda akan diizinkan untuk membaca gambar bom dari ST ROM karena tidak ada aturan yang mencegah Anda melakukannya. (Sebut saja versi TOS yang seharusnya bisa digunakan.)
— Arnauld
1
Oh WOW, itu membawa kembali kenangan. Komputer pertama saya adalah Atari ST. Saya ingat bom-bom itu dengan ketakutan.
— Rod
Selain: "Jumlah bom tergantung pada vektor pengecualian" - katakan apa ?! Ada alasan mengapa mereka tidak bisa menampilkan kode / kesalahan aktual? (Tidak pernah memiliki ST, saya dari kamp Amiga ... "Meditasi Guru" dan semua itu.)
— MrWhite

Jawaban:

20

Jelly , 43 44 byte

+1 byte - lupa menggandakan karakter (tidak ada yang memperhatikan!)

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

TryItOnline

Bagaimana?

Persiapan adalah untuk mengompresi data sebagai enkode run-length dari gambar asli:

  • Hitung panjang setiap run 1s (spasi) atau 0s (hash) dalam gambar, abaikan garis baru - menghasilkan daftar [4,2,11,1,1,...]:;
  • Kurangi satu dari setiap angka - ini memberikan kisaran [0,15];
  • Perlakukan ini sebagai angka dasar-16 (sebutkan nilai-nilai v,, dengan indeks iterbalik dan jumlah 16**i*v= 19468823747267181273462257760938030726282593096816512166437);
  • Ubah ini menjadi base-250 [5,119,249,42,...]:;
  • Peta ke halaman kode Jelly sebagai indeks: ¥vẏ)X;ndĊɓ¡ẹ3ċi}Ịɲ¡P

Sekarang kode mengevaluasi angka ini, memetakan huruf 1s dan 0s ke spasi dan karakter hash *, menggandakan masing-masing, membaginya menjadi garis-garis dan mengulangi masing-masing sesuai jumlah kali.
* sebenarnya implementasi dilakukan modulo 2 untuk menghemat byte, jadi spasinya ganjil dan hash genap:

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

05AB1E , 57 55 53 50 byte

Menggunakan pengodean CP-1252 .

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

Cobalah online!

Penjelasan

Karena gambar output hanya terdiri dari 2 karakter, kita dapat menampilkannya sebagai angka biner.
Kami dapat mengabaikan baris baru karena setiap baris memiliki panjang yang sama.
Kita dapat mengabaikan karakter terakhir dari setiap baris karena sama untuk semua baris.
Kami menggunakan gambar yang lebih tipis karena membutuhkan lebih sedikit ruang dan kami dapat dengan mudah menduplikasi setiap karakter nanti.

Menggunakan 1 untuk mewakili ruang dan 0 untuk mewakili # kita mendapatkan nomor biner:

111100111111111101011011111111111111101111111011011110111111110111000001111111111000001111111100000000011111000000000001111000000000001110000000000000110000000010000111000000010001111000000100001111100000000011111110000000111111111100011111

Kami kemudian mengonversikan ini ke basis-10 dan kemudian mengompresnya ke basis 214, basis maksimum di 05AB1E. Hasilnya adalah:

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

Daging program kemudian terdiri dari:

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

Pyth, 57 56 54 53 51 50 byte

Kode berisi karakter yang tidak patut xxddicetak , jadi ini hexdump yang dapat dibalik.

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

Cobalah online.

— PurkkaKoodari
sumber
11

JavaScript (ES6), 159 154 140 136 byte

Menyimpan banyak byte berkat @Hedi dan @Arnauld

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

Itu 104 karakter, tapi (sayangnya) 136 byte UTF-8. String dihasilkan dengan potongan ini:

Tampilkan cuplikan kode

Menggunakan .replacebukannya [...string].mapsama-sama panjang:

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

Bagaimana itu bekerja

Karena setiap baris data mentah dapat direpresentasikan sebagai angka 16-bit, kami dapat menyimpan seluruh file dalam string 16-char. Algoritma kompresi mengambil setiap baris biner, membaliknya dan membaliknya (karena setiap baris dalam aslinya berakhir dengan 0 , setiap baris dalam versi yang dimodifikasi sekarang dimulai dengan 1 ), kemudian mengubahnya menjadi char, dan menggabungkan karakter yang dihasilkan .

Untuk mendekompresnya, kita perlu mengekstrak charcode dan mengubah representasi binernya menjadi string hash dan spasi. Ini dapat dilakukan dengan fungsi rekursif, seperti:

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

fberulang kali mengambil bit terakhir q, memilih dua spasi jika 1 atau dua hash jika 0, lalu menyatukannya dengan hasil menjalankan fsisanya q. Ini dijalankan x.charCodeAt(), mengubah kode-char menjadi string spasi dan hash yang benar.

(Ada lebih banyak drama di sini sebelumnya, tetapi teknik penghematan 4-byte menghapus semua itu.)

Setelah itu, kita bisa mengulang nkali string dan menambahkan baris baru. Ini adalah metode dekompresi terpendek yang saya temukan, tetapi jangan ragu untuk menyarankan metode yang mungkin lebih pendek.

Upaya lain untuk mengompresi string:

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

Yang pertama dari ini adalah 153 byte, sehingga tidak ada yang mendekati 136 ...

— Produksi ETH
sumber
Bisa menghemat beberapa byte dengan +x?'##':' 'alih - alih" #"[x].repeat(2)
— Hedi
@Hedi terima kasih, saya tahu ada cara untuk bermain golf sedikit itu.
— ETHproduksi
2
Bisakah Anda langsung menguji bit x.charCodeAt()daripada mengubahnya menjadi biner? (Saya pikir itu akan menghemat sekitar 8 byte.)
— Arnauld
2
Algoritma kompresi Anda terdengar hampir kriptografis .
— Justin
1
@ Justin Sialan, saya baru saja akan berkomentar itu.
— user253751
10

File MS-DOS .COM, 84 byte

BAIK. Hanya untuk bersenang-senang karena saya tidak bisa mengalahkan 50 byte ...

Dicoba di bawah DOSbox serta di bawah MS-DOS 6.22 di mesin virtual.

Di bawah DOSbox, program ini bekerja dengan baik tetapi di bawah MS-DOS nyata output tidak akan ditampilkan dengan benar karena DOS membutuhkan CR-LF bukan LF di akhir baris.

(Namun hasilnya benar.)

Varian 88 byte akan menggunakan CR-LF di akhir baris.

Ini filenya:

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

Kode assembler (dalam sintaks AT&T) terlihat seperti ini:

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

--- Sunting ---

Saya lupa menyebutkan: Program harus dimulai dengan baris perintah berikut:

Nama file COM + tepat satu karakter spasi + Jumlah bom (1-9)

— Martin Rosenau
sumber
1
Bagus. Kami masih kekurangan 68.000 jawaban, tetapi jawaban ini semakin dekat. :-)
— Arnauld
objdump -dwoutput adalah cara yang baik untuk menunjukkan biner mentah, karena Anda melihat byte mana yang instruksi. Saya melakukan itu untuk jawaban gcd dan adler32 . (Serta menyertakan kode sumber yang dikomentari bagi orang-orang untuk mencoba sendiri.)
— Peter Cordes
8

Python, 223 179 byte

Pendekatan kedua:

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

Cobalah di repl.it!

Daripada membuat daftar string on-the-fly, ada string heksadesimal kode keras yang diindeks dan dikonversi ke biner; kemudian setiap digit biner diubah menjadi salah satu ' 'atau '#', yang digandakan dan digabungkan bersama ... dll

Pendekatan pertama:

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

Cobalah di repl.it!

Ini berisi daftar hard-string dari setiap baris (tidak termasuk spasi tambahan) yang dibuat dengan menduplikasi salah satu ' 'atau '##'beberapa kali. Untuk masing-masing string ini, mereka diisi dengan spasi hingga 32 karakter, digandakan nkali, kemudian digabungkan dengan baris baru.

— Hactar
sumber
Anda dapat menghemat satu byte dengan beralih ke mencetak generator yang tidak gulungan, alih-alih bergabung '\n'. Jadi, 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))). Juga, Anda tidak perlu menghitung byte yang diperlukan untuk menetapkan nama lambda. Jadi skor Anda bisa 176.
— Morgan Thrapp
6

C, 250 240 208 188 byte

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

Beralih ke menggunakan fungsi.

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

Tes seperti ini. main(c,v)char**v; { f(atoi(v[1])); } 

a.exe 2
        ####                            ####                        
  ##  ##    ##                    ##  ##    ##                  
              ##                              ##                    
##    ##        ##              ##    ##        ##              
    ##      ##########              ##      ##########          
            ##########                      ##########          
        ##################              ##################      
      ######################          ######################    
      ######################          ######################    
    ##########################      ##########################  
    ################  ########      ################  ########  
      ##############  ######          ##############  ######    
      ############  ########          ############  ########    
        ##################              ##################      
          ##############                  ##############        
              ######                          ######
— Cleblanc
sumber
Anda dapat menyimpan beberapa byte dengan menggunakan representasi desimal dari angka hex tersebut untuk kehilangan 0x.
— Tembaga
@ Copper Terima kasih, saya berhasil mencukur beberapa byte juga menggunakan tulis di tempat putchar.
— cleblanc
6

/// , 539 532 + no. bom byte

/// Jawab pertama, menampilkan 4 bom. Akhir empat 1 dapat diganti dengan representasi bom yang ingin Anda cetak (11 untuk 2, 111 untuk 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

Cobalah online!

Jika input harus desimal, berikut ini memiliki 555 548 byte (di mana digit terakhir dapat diubah menjadi 1, 2, 3 atau 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

Cobalah online!

Bagian terpenting dari kode adalah:
| berarti //
ABCDEFGHIJKLMNOP berarti setiap baris bom masing-masing
S berarti 2 spasi
s berarti 4 spasi
* berarti 6 spasi
q berarti 8 spasi
T berarti ## (2)
t berarti #### (4)
^ berarti ##### # (6)
r berarti ######## (8)
& berarti ################ (16)
Sebagian besar kode memastikan bahwa bom dicetak. berdampingan, tidak di atas satu sama lain.

— boboquack
sumber
5

CJam , 66 byte

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

Cobalah online! (perhatikan bahwa ada beberapa karakter yang tidak patut ditulis dalam kode.)

Bom di disandikan sebagai angka dalam biner menggunakan 1 untuk spasi (ruang terdepan sebagai 1 memastikan kita tidak harus mengisi representasi biner), mengubah urutan, dan kemudian dikonversi ke string di basis-136 (yang menghasilkan string terpendek tanpa karakter lebar). Langkah-langkah ini bisa dimainkan di sini .

Jawaban ini kemudian membalikkan penyandian, trik utama adalah mengulangi bom sebelum mentransposisi, secara efektif merangkai setiap baris bom sekaligus. Karakter di setiap baris kemudian dapat digandakan dengan baris baru dimasukkan untuk hasil akhir.

— Linus
sumber
5

PHP, 138 104 + 32 = 136 byte

Saya tidak pernah berpikir fileitu biner aman. Saya hanya berharap saya akan menemukan cara yang lebih menarik untuk menyimpan data; tapi tidak ada yang saya coba kalahkan biner mentah.

foreach(unpack("v*",file(b)[0])as$v)echo"
",str_repeat(strtr(sprintf("%016b",$v),["  ","##"]),$argv[1]);
  • baca data biner dari file, ekstrak dari little endian 16bit ke array int
  • loop through array: mencetak biner 16 digit ke string, ganti 0dengan 2 spasi, 1dengan ##, waktu
    pengulangan $argv[1], hasil cetak + baris baru

jalankan bersama -r

data biner dalam file b:

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

kode untuk menghasilkan file:

$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
sumber
2
Anda dapat menyimpan 2 byte dengan menggunakan pemecah baris terkemuka daripada yang tertinggal dan dengan demikian tidak memiliki ruang setelah gema dan dengan menggunakan pemecah baris yang sebenarnya daripada \n.
— user59178
@ user59178 saya tahu. tolong jangan begitu verbose.
— Titus
5

MATL , 64 63 60 59 58 byte

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

Cobalah online!

Penjelasan

Kode ini menggunakan versi pra-kompresi dari matriks biner 16 × 16. Pra-kompresi (bukan bagian dari program) menggunakan dua langkah:

  1. Pengkodean run-length dari matriks dibaca dalam urutan baris-utama (pertama melintasi, lalu turun).
  2. Panjang run yang dihasilkan berkisar dari 1 hingga 16, sehingga vektor run-length minus 1 dikonversi dari basis 16 ke basis 94 (untuk menggunakan semua kode ASCII yang dapat dicetak kecuali kutipan tunggal, yang tidak digunakan karena perlu melarikan diri).

String yang dikompresi,

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

didekompresi dari basis 94 ke basis 16:

                                   F16Za

Vektor run-lenghts plus 1 yang diperoleh dikalikan dengan 2:

                                        QE

untuk melakukan peregangan horizontal.

Vektor run-lenghts berisi 49 nilai. Nomor asli yang harus diulang dengan panjang itu harus [0 1 0 1 ... 0](49 entri). Tetapi alih-alih itu, lebih pendek untuk menggunakan vektor [1 2 ... 49], yang akan sama-sama valid berkat pengindeksan modular. Jadi decoding run-length adalah

49:                                       Y"

Vektor yang dihasilkan containis berjalan dari 1, 2, ... 49, untuk total 512 entri. Ini dibentuk kembali menjadi matriks 16 × 32:

                                            32e!

dan digunakan sebagai indeks modular ke dalam string ' #'untuk menghasilkan bom tunggal:

                                                ' #'w)

Akhirnya, pengulangan horizontal oleh faktor yang diberikan oleh input menghasilkan hasil yang diinginkan:

                                                      liX"
— Luis Mendo
sumber
4

Python 2: 143 byte

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

Ada di ideone

(Saya menyadari bahwa penyandian langsung bom asli di pangkalan 36 dibuat untuk kode yang lebih pendek dengan Python.)

Tali dibentuk dengan memperlakukan spasi sebagai 1s dan hashes sebagai 0s, dan kemudian mengkonversi ke basis 36. Program kemudian mengkonversi kembali ke biner dan diiris menjadi panjang 16 (dengan offset 2 untuk '0b' di depan Python. string biner), mengkonversi ke spasi ganda dan hash ganda, menggabungkannya, mengulang nkali string dan mencetak.

Sebelumnya: Python 2, 169 166 163 byte

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

Ada di ideone

Hampir satu port jawaban Jelly saya .

— Jonathan Allan
sumber
Tidak efisien baik jika lebih pendek. Bagus +1
— ElPedro
4

Python 2.7, 144 141 byte

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

Bom ditulis dalam biner dengan 1 untuk ruang, 1 yang terkemuka menghilangkan kebutuhan untuk melapisi representasi biner. Bom itu ditransposisikan (mirip dengan jawaban CJam saya ) dan disimpan di pangkalan 36.

Program ini menerjemahkan bom ke biner dan mengulang bit dengan langkah 16 secara efektif mengikuti transposisi (yang menghemat byte lebih dari memotong garis yang diberikan). Baris yang dihasilkan digabungkan, bit diganti dengan dua kali lipat atau #, dan bergabung menjadi string menghanguskan.

— Linus
sumber
1
Anda dapat menjatuhkan nol di depan dari nomor basis 36 Anda.
— Jonathan Allan
@ JonathanAllan: Tangkapan bagus. Saya pikir itu Okarena suatu alasan ...
— Linus
4

C (gcc) , 216 204 183 165 134 byte

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

Cobalah online!

Ditulis sebagai program mandiri ( 201 183 151 byte)

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

Cobalah online!

Segfault ini jika parameter baris perintah tidak diberikan.

— plafon
sumber
3

Batch, 415 byte

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

Catatan: garis set s=berakhir dalam 5 spasi. Menerima hitungan sebagai parameter baris perintah. Cukup lilitkan melalui setiap baris bom (dikompresi sangat sedikit dengan menghilangkan lintasan 5 karakter identik) lalu ulangi bom sebanyak yang diinginkan sebelum akhirnya menduplikasi masing-masing karakter.

— Neil
sumber
3

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

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

Melihat Hex untuk daftar nomor tetapi tampaknya tidak cukup menabung untuk membuatnya sepadan. Berharap bisa menurunkan kode tapi sepertinya sudah sejauh yang saya bisa dengan pendekatan ini. Semua petunjuk tambahan diterima dengan rasa terima kasih.

SUNTING

-1 dengan mengubah e==1ke e>0. Saya selalu lupa itu.

-2 dengan mengabaikan panjang string biner, menambahkan 7 0's dan hanya mengambil 16 elemen terakhir. Bekerja karena tidak pernah lebih dari 7 yang memimpin 0's.

-4 karena sekarang saya telah kehilangan referensi kedua ke variabel b yang dapat saya gunakan bin(y)[2:]langsung pada fungsi peta dengan mengambilnya di bawah magic 200 :-)

-8 dengan menggunakan slice assignment pada daftar kedua. Belajar sesuatu yang baru malam ini.

-3 dengan terima kasih kepada @Jonathan

-2 dengan menggunakan c=d=([0]*7+map(int,bin(y)[2:]))[-16:]alih-alih memilikic=d;

-2 lagi terima kasih kepada @Jonathan

-24 dengan terima kasih kepada @Linus

Keluaran

python bombs.py
2
        ####                            ####                    
  ##  ##    ##                    ##  ##    ##                  
              ##                              ##                
##    ##        ##              ##    ##        ##              
    ##      ##########              ##      ##########          
            ##########                      ##########          
        ##################              ##################      
      ######################          ######################    
      ######################          ######################    
    ##########################      ##########################  
    ################  ########      ################  ########  
      ##############  ######          ##############  ######    
      ############  ########          ############  ########    
        ##################              ##################      
          ##############                  ##############        
              ######                          ######
— ElPedro
sumber
" #"[e>0]*2akan bekerja
— Jonathan Allan
DOH! Bagaimana saya melewatkan yang itu ??? Terima kasih @ Jonathan
— ElPedro
... tanda kurung juga (...)bisa (RE: per komentar saya sebelumnya).
— Jonathan Allan
Anda dapat membawanya ke 170 denganfor y in ...:print"".join(" #"[e>0]*2for e in(([0]*7+map(int,bin(y)[2:]))[-16:]))*z
— Jonathan Allan
@Jonathan Terima kasih lagi. sudah terlambat di sini jadi saya akan menyimpan perubahan itu untuk besok jadi saya tidak mengacaukannya sepenuhnya.
— ElPedro
3

RProgN , 210 193 Bytes

Menyimpan beberapa byte dengan beralih 0 = '' 1 = '##' ke 1 = '' 0 = '', ini berarti saya tidak perlu menambahkan angka nol kembali. Juga, ini berarti bahwa sekarang string B64 yang dulu mengatakan "MAFIA" tidak, Ini menyedihkan.

'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

Penjelasan

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

Cukup panjang, Ekspansi, pencetakan, dan semacamnya dari string terkompresi adalah 105 byte. Mungkin sedikit lebih golf, tetapi setidaknya itu berfungsi.

Input secara implisit ada di stack, stack dicetak secara implisit.

Keluaran

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

Cobalah!

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

— ATaco
sumber
3

PHP, 144 140 139 138 136 byte

Catatan: menggunakan pengkodean Windows-1252

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

Jalankan seperti ini:

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

Atau menggunakan pengkodean IBM-850 (135 byte dan hasil yang lebih cantik):

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

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

Penjelasan

Ini tidak melakukan hal-hal biner dan tidak memerlukan file eksternal.

Setiap angka 16 bit dibalik, kemudian dikodekan sebagai nomor basis-36, diisi dengan yang pertama 0jika perlu, sehingga setiap 16 bit menghasilkan 3 byte. Menggabungkan hasil-hasil di 01c02203k07d1j81j46b4cmwcmwpa4ohobugc8o6b434w0ow. Kode membalikkan proses sehingga bom dicetak dengan benar Nkali.

Tweaks

  • Disimpan 4 byte dengan hanya menggunakan satu untuk-loop
  • Menyimpan byte dengan mencetak char tunggal untuk setiap iterasi dan menggunakan indeks string, bukan ternary
  • Menyimpan byte dengan mengatur ulang $jke nol pada batas garis %=. Ini menghilangkan tanda kurung
  • Disimpan 2 byte dengan menggunakan $argn
— aross
sumber
3

GCC C 129 byte

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

Dalam satu baris:

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

Jalankan dengan:

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

Kompilasi sumber sebagai ISO8859-x (ASCII).

NB óÿÿþÿoÜüðààÀÀ! ÀCàCðøþ? harus mengandung Kode ASCII yang tidak terlihat tetapi telah rusak karena cara StackExchange menyajikan kontennya. Silakan lihat tautan ideaone untuk pengkodean pengujian yang tepat Sebagai alternatif, ASCII String asli ada di: https://github.com/claydonkey/AtariBombs/blob/master/ISO8859_REPR2.txt

Penjelasan

Pertama, konversi representasi hex bom [f3 ff ad ff fe ff 6f 7f dc 1f fc 1f f0 07 e0 03 e0 03 c0 01 c0 21 c0 21 e0 43 f0 07 f8 0f fe 3f] ke UTF-8 (dalam Versi UTF-8 kompiler menyimpan string sebagai Wide Char Array - 2 atau 4 byte untuk setiap karakter saat runtime tetapi ini bersifat akademis). Sedangkan karakter UTF-8 akan disimpan sebagai 2-4 byte, nilai-nilai ini semuanya dalam ISO-8859-1 (ASCII) dan karenanya hanya membutuhkan 1 byte. Juga aman untuk disimpan sebagai ISO-8859-x (tidak ada nilai 0x8_ atau 0x9_). Oleh karena itu teks mengkonsumsi 32 byte dalam ISO-8859 dan rutin mengkonsumsi total 135 byte.

(NB wide chars disimpan sebagai integer 16 bit di windows dan 32bit di linux tapi sekali lagi ini tidak relevan dengan tugas yang ada)

Peringatan: Tidak semua karakter dapat ditampilkan (karakter kontrol di bawah 0x20). Namun, masih ada. Sebagian besar halaman web utf-8 / 8859/1253 ( https://w3techs.com/technologies/overview/character_encoding/all ) jadi saya rasa ini sah (menggeser semua nilai di bawah 0x20 ke printable ASCII harus memperbaikinya).

UTF-8

Ini adalah versi yang lebih dekat dengan postingan asli dengan sumber yang disandikan UTF-8. Ini mengkonsumsi 173 byte. String itu sendiri menjadi 50 byte sumber. Rutin juga lebih lama karena ASCII byte sekarang disimpan dengan padding 0's untuk Wide Chars 16bit / 32bit dan harus digeser bukannya dicor ke uint16_t seperti di atas. Saya terus menggunakan ini karena dapat diverifikasi dengan ideone yang menggunakan pengkodean 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)?"  ":"##")));}

Jalankan dengan:

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

Jika Anda dapat mengatur nilai implisit ke integer 16bit di kompiler Anda, Anda dapat menghilangkan deklarasi tipe wchar_t dari Wide Char. Ideone tidak mengeluh, jadi saya rasa sebaiknya pergi.

Cobalah di ideone

— Claydonkey
sumber
Impresif. Pengkodean apa yang digunakan ini?
— DJMcMayhem
Ini dikompilasi pada MinGW GCC di mana karakter lebar adalah uint16. Oleh karena itu pengodeannya adalah [16-bit type holding UTF-16 Unicode]. Namun, saya pikir itu karena karakter berada dalam 0xFF (16bit) mereka diperpanjang ASCII. + Jadi tidak ada yang istimewa
— claydonkey
Maaf saya telah belajar sedikit lebih banyak tentang pengkodean dan mungkin salah tentang hal itu disimpan sebagai UTF-16. silakan merujuk ke jawaban yang dirombak.
— claydonkey
2

Haskell, 155 byte

Sebagai fungsi dengan tipe 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]]

Mencetak ke IO secara langsung akan dikenakan biaya 5 byte (atau 6 jika kita lebih suka mengembalikan IO ()daripada 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
sumber
2

C, 175 byte

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

menggabungkan setiap x ke dirinya sendiri dan membuat p overflow untuk mengakhiri setiap baris.

ah, saya mengubah printf () untuk menulis ketika bermain golf dan itu memecahkannya. menguji sini ideone.com/JtHInD
2

Java, 228 byte

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
sumber
1
Saya tahu ini sudah setahun, tetapi Anda bisa menggunakannya untuk ini: 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 byte ) Selain menggunakan Java 8 lambda, saya telah mengurangi lebih banyak byte dengan mengubah: posisi x=16(dan berubah whilemenjadi for); 2x ==0ke <1; mengembalikan salih-alih mencetaknya (impor juga merupakan bagian dari byte-count btw ..); --x>=0untuk x-->0. Tetap saja, jawaban yang bagus, jadi +1!
— Kevin Cruijssen
@KevinCruijssen Terima kasih (pertimbangkan memposting ini sebagai jawaban sendiri). Saya tidak terlalu aktif di sini pada codegolf, dan dengan demikian saya tidak yakin tentang aturan, tapi saya pikir dalam kebanyakan kasus, hanya menghitung byte dari fungsi (dan mengabaikan impor) diperbolehkan.
— Marco13
Agak terlalu mirip dengan posting sebagai jawaban yang terpisah, tetapi saya bisa mengerti jika Anda tidak ingin mengedit jawaban Anda lebih dari setahun yang lalu. :) Saya hanya akan meninggalkannya di komentar. Dan saya khawatir impor memang masuk hitungan byte-count.
— Kevin Cruijssen
2

J, 89 byte

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

Mengkodekan string sebagai angka dasar-95, menambah setiap digit dengan 32, kemudian mewakilinya dengan string ascii.

Penjelasan

Ini terdiri dari dua bagian utama. Ada konstruksi bom, dan pengulangan yang sebenarnya. Mari kita sejenak menyebut bom sebagai b. Kemudian, kode tersebut terlihat seperti:

|:@;@#&(b)

Saat dipanggil dengan input k, ini setara dengan:

|: ; (k#b)

badalah bom kotak, jadi k#bbuat kpengulangan b, ;ratakan secara vertikal, dan |:transpos hasilnya. (Bom bitu sendiri dibangun secara dialihkan.)

Sekarang, inilah bomnya:

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

String berikut adalah string basis-95 yang dikodekan dengan offset 32, sehingga semua karakter termasuk dalam rentang ASCII, dan untungnya tidak ada 's yang perlu diloloskan. 3 u:mendapatkan kode char dari string, 32x-~membuat setiap angka nomor e xtended dan mengurangi 32darinya; 95#.mengkonversi ke nomor basis-95 dan 2#.invmengubahnya menjadi array digit biner. Saya menambahkan terkemuka 1ke biner untuk membuatnya menjadi angka yang solid, jadi saya melepasnya }.. Saya membentuk array menjadi tabel 16x16 dengan 16 16$kemudian memindahkannya menggunakan |:. (Kemungkinan golf untuk nanti: transpos string yang disandikan secara literal.) 2#Menduplikat setiap karakter dengan lebar. Kita dibiarkan dengan tabel 0s dan 1s.' #'{~peta 0s ke ' 'dan 1ke '#'. Karena itu, kita dibiarkan dengan bom kita.

Kasus cobaan

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

BaCon , 229 227 195 byte

Kontribusi dalam BASIC demi nostalgia. Variabel 'a' menentukan jumlah bom.

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}

Keluaran :

        ####                            ####                    
  ##  ##    ##                    ##  ##    ##                  
              ##                              ##                
##    ##        ##              ##    ##        ##              
    ##      ##########              ##      ##########          
            ##########                      ##########          
        ##################              ##################      
      ######################          ######################    
      ######################          ######################    
    ##########################      ##########################  
    ################  ########      ################  ########  
      ##############  ######          ##############  ######    
      ############  ########          ############  ########    
        ##################              ##################      
          ##############                  ##############        
              ######                          ######
— Peter
sumber
2

Haskell, 191 181 byte

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

C (Atari TOS 2.06 US), 129 124 117 113 byte

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

Ini menggunakan bitmap bom dari TOS ROM, yang sedikit berbeda dari yang ada di pertanyaan. Untuk TOS versi lain, Anda harus menyesuaikan alamat yang ditunjuk oleh *a. Perhatikan bahwa beberapa ROM emulator tidak termasuk bitmap bom!

Jika Anda tidak memberikan argumen baris perintah, beberapa bom bitmap resolusi tinggi dapat ditampilkan :-)

— plafon
sumber
1

C ++ 11, 252 byte

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

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

tangkapan layar
(Cuplikan layar versi tanpa karakter yang digandakan)
SB memiliki font persegi, jadi menggandakan karakter terlihat buruk (dan tidak muat di layar)
Karakter non-ASCII telah digantikan oleh x.
Nilai hex: 0008,0002,0610,1F8A,3FC1,7FC1,7FF2,FFF4,FFF8,EFF0,73F0,7FC0,3FC0,1F80,0600
Karena SB menyimpan file dalam UTF-8, beberapa di antaranya dihitung sebagai 2 atau 3 byte.

— 12Me21
sumber
@Arnauld Saya tidak tahu banyak tentang SmileBASIC, tetapi mengingat bahwa ada loop FOR K=1TO Ndengan INPUT N, saya pikir ini akan menampilkan jumlah bom yang diberikan dalam input. Namun, saya harus mengatakan bahwa meskipun font persegi, saya percaya karakter masih harus digandakan untuk tetap konsisten dengan persyaratan (untuk menghindari keunggulan dibandingkan jawaban lain). Anda dapat menyimpan yang saat ini untuk solusi yang tampak lebih bagus, tetapi saya pikir Anda masih harus menambahkan solusi yang benar. Setelah Anda menambahkan itu, saya akan mendukung penggunaan kreatif karakter UTF-8!
— HyperNeutrino
@AlexL. Ya, komentar saya sebelum pembaruan kode.
— Arnauld
1

Ruby 2.x (lambda) - 157 byte

Mungkin bisa bermain golf lebih lanjut, tapi saya suka versi ini:

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

Gagasan serupa dengan versi python: pecahkan string bom yang disandikan heksadesimal menjadi bagian-bagian dari 4 karakter, konversikan ke biner, terjemahkan 1ke# dan 0ke , menggandakan setiap karakter, dan mencetak array yang dihasilkan.

Perhatikan bahwa put digunakan untuk mencetak array. Ini akan mencetak array satu baris per elemen.

— Nerketur Kamachi
sumber
1

Excel VBA, 204 Bytes

VBE Anonymous Fungsi jendela langsung yang mengambil input dari rentang [A1]dan keluaran ke Objek 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

Keluaran

Babomb

— Taylor Scott
sumber
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.