Giới thiệu

Các Atari ST là một máy tính cá nhân khá phổ biến từ giữa 80 để đầu kỷ nguyên 90, trang bị một bộ vi xử lý Motorola 68000. Trên máy này, hành vi mặc định của hệ điều hành đối với các ngoại lệ CPU chưa được phát hiện là hiển thị một hàng bom trên màn hình, như trong hình sau:

_{Nguồn: https :
//commons.wik mega.org/wiki/File:Row_of_bombs.png NB: Tùy thuộc vào phiên bản HĐH, đồ họa bom có ​​thể thay đổi đôi chút. Nhưng hãy lấy cái này làm tài liệu tham khảo.}

Số lượng bom phụ thuộc vào vectơ ngoại lệ, phổ biến nhất là:

• ($ 008) Lỗi xe buýt: 2 quả bom
• ($ 00c) Lỗi địa chỉ: 3 quả bom
• ($ 010) Hướng dẫn bất hợp pháp: 4 quả bom

Mục tiêu

Mục tiêu của bạn là viết một chương trình hoặc chức năng in hoặc xuất ra một nghệ thuật ASCII của những quả bom Atari ST như vậy.

Đầu vào

Một số nguyên biểu thị số lượng bom cần hiển thị. Mã của bạn phải hỗ trợ các giá trị phổ biến nhất: 2, 3 và 4. Hỗ trợ ít hơn và / hoặc nhiều quả bom là tốt, nhưng nó không bắt buộc cũng không phải chịu tiền thưởng.

Đầu ra

Bom ban đầu bao gồm một ô pixel 16x16 pixel, được thể hiện ở đây trong cả ASCII và nhị phân:

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

Trong thử thách này, mỗi quả bom ASCII phải được kéo dài gấp đôi chiều rộng ban đầu của nó để hiển thị tốt hơn. Do đó, nó sẽ bao gồm 16 hàng gồm 32 ký tự, sử dụng ##cho các pixel 'BẬT' và hai khoảng trắng cho các pixel 'TẮT'. Tất cả gạch bom phải được đặt cạnh nhau. Không gian hàng đầu bị cấm. Không gian lưu trữ cũng bị cấm, ngoại trừ những không gian thực sự là một phần của khối bom (tức là cột thứ 31 và 32) phải có mặt. Bạn có thể bao gồm không quá một lần ngắt dòng hàng đầu và không quá một lần ngắt dòng.

Thí dụ

Dưới đây là đầu ra tham chiếu cho hai quả bom, trong đó các ngắt dòng bắt buộc được đánh dấu là \nvà các ngắt dòng bổ sung được đánh dấu là (\n):

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

(Tất nhiên, các định dạng ngắt dòng khác như \rhoặc \r\ncũng có thể được sử dụng.)

Quy tắc

Đây là môn đánh gôn, vì vậy câu trả lời ngắn nhất bằng byte sẽ thắng. Sơ hở tiêu chuẩn bị cấm.

Thạch , 43 44 byte

+1 byte - quên nhân đôi số ký tự (không phải ai cũng nhận thấy!)

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

Dùng thử

Làm sao?

Chuẩn bị là nén dữ liệu dưới dạng mã hóa chiều dài của ảnh gốc:

• Đếm độ dài của mỗi lần chạy 1s (dấu cách) hoặc 0s (hàm băm) trong ảnh, bỏ qua các dòng mới - mang lại một danh sách : [4,2,11,1,1,...];
• Trừ một từ mỗi số - điều này cho một phạm vi [0,15];
• Coi đây là số cơ sở-16 (liệt kê các giá trị v, với chỉ số ingược lại và tổng hợp 16**i*v= 19468823747267181273462257760938030726282593096816512166437);
• Chuyển đổi này thành cơ sở-250 : [5,119,249,42,...];
• Ánh xạ vào trang mã của Jelly dưới dạng chỉ mục: ¥vẏ)X;ndĊɓ¡ẹ3ċi}Ịɲ¡P

Bây giờ mã đánh giá số này, ánh xạ 1s và 0s vào khoảng trắng và ký tự băm *, nhân đôi số, chia thành các dòng và lặp lại mỗi số lần thích hợp.
* thực sự việc thực hiện được thực hiện theo modulo 2 để lưu byte, do đó, khoảng trắng là số lẻ và giá trị băm là:

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

Sử dụng mã hóa CP-1252 .

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

Hãy thử trực tuyến!

Giải trình

Vì hình ảnh đầu ra chỉ bao gồm 2 ký tự, chúng ta có thể biểu thị nó dưới dạng số nhị phân.
Chúng ta có thể bỏ qua các dòng mới vì mọi dòng có cùng độ dài.
Chúng ta có thể bỏ qua char cuối cùng của mỗi hàng vì nó giống nhau cho tất cả các hàng.
Chúng tôi sử dụng hình ảnh mỏng hơn vì nó chiếm ít không gian hơn và chúng tôi có thể dễ dàng sao chép từng ký tự sau này.

Sử dụng 1 để thể hiện không gian và 0 để đại diện cho # chúng ta có được số nhị phân:

111100111111111101011011111111111111101111111011011110111111110111000001111111111000001111111100000000011111000000000001111000000000001110000000000000110000000010000111000000010001111000000100001111100000000011111110000000111111111100011111

Sau đó, chúng tôi chuyển đổi nó thành cơ sở 10 và sau đó nén nó thành cơ sở 214, cơ sở tối đa trong 05AB1E. Kết quả của việc này là:

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

Thịt của chương trình sau đó bao gồm:

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

Mã này chứa các ký tự không thể in được, vì vậy đây là một xxdhexdump có thể đảo ngược .

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

Hãy thử trực tuyến.

JavaScript (ES6), 159 154 140 136 byte

Đã lưu rất nhiều byte nhờ @Hedi và @Arnauld

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

Đó là 104 ký tự, nhưng (đáng buồn thay) 136 UTF-8 byte. Chuỗi được tạo với đoạn mã này:

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(","))

Sử dụng .replacethay vì [...string].mapdài bằng nhau:

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

Làm thế nào nó hoạt động

Vì mỗi hàng của dữ liệu thô có thể được biểu diễn dưới dạng số 16 bit, chúng tôi có thể lưu trữ toàn bộ tệp trong chuỗi 16 ký tự. Thuật toán nén lấy từng hàng nhị phân, lật nó và đảo ngược nó (vì mọi hàng trong bản gốc kết thúc bằng 0 , mọi hàng trong phiên bản sửa đổi bây giờ bắt đầu bằng 1 ), sau đó biến nó thành char và ghép các ký tự kết quả .

Để giải nén nó, chúng ta cần trích xuất charcode và biến biểu diễn nhị phân của nó thành một chuỗi băm và dấu cách. Điều này có thể được thực hiện với một hàm đệ quy, như vậy:

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

fliên tục lấy bit cuối cùng q, chọn hai khoảng trắng nếu đó là 1 hoặc hai giá trị băm nếu là 0, sau đó kết hợp nó với kết quả chạy ftrong phần còn lại q. Điều này được chạy trên x.charCodeAt(), biến mã char thành chuỗi không gian và băm chính xác.

(Trước đây đã có nhiều kịch tính hơn ở đây, nhưng kỹ thuật tiết kiệm 4 byte đã xóa tất cả những điều đó.)

Sau đó, chúng ta chỉ có thể lặp lại nthời gian chuỗi và thêm một dòng mới. Đây là phương pháp giải nén ngắn nhất mà tôi đã tìm thấy, nhưng hãy thoải mái đề xuất bất kỳ phương pháp nào có thể ngắn hơn.

Các nỗ lực khác trong việc nén chuỗi:

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

Đầu tiên trong số này là 153 byte, vì vậy không ai trong số họ đến bất cứ nơi nào gần 136 ...

Tệp MS-DOS .COM, 84 byte

ĐỒNG Ý. Chỉ để giải trí vì tôi không thể đánh bại 50 byte ...

Đã thử dưới DOSbox cũng như dưới MS-DOS 6.22 trong một máy ảo.

Trong DOSbox, chương trình hoạt động tốt, tuy nhiên trong MS-DOS thực, đầu ra sẽ không được hiển thị chính xác vì DOS yêu cầu CR-LF thay vì LF ở cuối dòng.

(Tuy nhiên, đầu ra là chính xác.)

Một biến thể 88 byte sẽ sử dụng CR-LF ở cuối dòng.

Đây là tập tin:

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

Mã trình biên dịch chương trình (theo cú pháp AT & T) trông như thế này:

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

--- Biên tập ---

Tôi quên đề cập: Chương trình phải được bắt đầu bằng dòng lệnh sau:

Tên của tệp COM + chính xác một ký tự khoảng trắng + Số bom (1-9)

Python, 223 179 byte

Cách tiếp cận thứ hai:

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

Hãy thử nó trên repl.it!

Thay vì tạo một danh sách các chuỗi đang hoạt động, có một chuỗi thập lục phân cứng được lập chỉ mục và chuyển đổi thành nhị phân; sau đó mỗi chữ số nhị phân được biến thành một ' 'hoặc '#', được nhân đôi và nối lại với nhau ... vv

Cách tiếp cận đầu tiên:

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

Hãy thử nó trên repl.it!

Điều này chứa một danh sách mã hóa cứng của các chuỗi của mỗi dòng (không bao gồm các khoảng trắng ở cuối) được tạo bằng cách sao chép một ' 'hoặc '##'một số lần. Đối với mỗi chuỗi này, chúng được đệm bằng khoảng trắng cho đến 32 ký tự, nthời gian trùng lặp , sau đó được nối với dòng mới.

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

Chuyển sang sử dụng một chức năng.

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

Kiểm tra như thế này. main(c,v)char**v; { f(atoi(v[1])); }

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

/// , 539 532 + không. bom byte

Câu trả lời đầu tiên ///, hiển thị 4 quả bom. Phần cuối của 4 1 có thể được thay thế bằng bất kỳ đại diện đơn nhất nào về số lượng bom bạn muốn in (11 cho 2, 111 cho 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

Hãy thử trực tuyến!

Nếu đầu vào phải là số thập phân, thì sau đây có 555 548 byte (trong đó chữ số cuối cùng có thể được thay đổi thành 1, 2, 3 hoặc 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

Hãy thử trực tuyến!

Các phần quan trọng nhất của mã là:
| có nghĩa là //
ABCDEFGHIJKLMNOP có nghĩa là mỗi dòng bom tương ứng
S có nghĩa là 2 khoảng cách
s có nghĩa là 4 khoảng cách
* có nghĩa là 6 khoảng cách
q có nghĩa là 8 khoảng cách
T có nghĩa là ## (2)
t có nghĩa là #### (4)
^ có nghĩa là ##### # (6)
r có nghĩa là ######## (8)
& có nghĩa là ################ (16)
Hầu hết các mã đều đảm bảo rằng bom được in cạnh nhau, không chồng lên nhau.

CJam , 66 byte

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

Hãy thử trực tuyến! (lưu ý rằng có một số ký tự không thể in được trong mã.)

Bom được mã hóa thành số nhị phân sử dụng 1 cho khoảng trắng (không gian hàng đầu là 1 đảm bảo chúng ta không phải đệm các biểu diễn nhị phân), chuyển đổi, sau đó chuyển đổi thành chuỗi trong cơ sở 136 (tạo ra chuỗi ngắn nhất không có ký tự rộng). Các bước này có thể được chơi với ở đây .

Câu trả lời này sau đó đảo ngược mã hóa, mẹo chính là lặp lại quả bom trước khi chuyển vị, nối hiệu quả từng dòng bom cùng một lúc. Các ký tự trong mỗi dòng sau đó có thể được nhân đôi với các dòng mới được chèn cho đầu ra cuối cùng.

PHP, 138 104 + 32 = 136 byte

Tôi chưa bao giờ nghĩ rằng đó filelà an toàn nhị phân. Tôi chỉ ước rằng tôi đã tìm thấy một cách thú vị hơn để lưu trữ dữ liệu; nhưng không có gì tôi đã cố gắng đánh bại nhị phân thô.

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

• đọc dữ liệu nhị phân từ tệp, giải nén từ 16 bit endian nhỏ vào mảng int
• lặp qua mảng: in nhị phân 16 chữ số thành chuỗi, thay thế 0bằng 2 khoảng trắng, 1với ##, thời gian
  lặp lại $argv[1], kết quả in + dòng mới

chạy với -r

dữ liệu nhị phân trong tệp b:

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

mã để tạo tập tin:

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

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

Hãy thử trực tuyến!

Giải trình

Mã này sử dụng phiên bản được nén trước của ma trận nhị phân 16 × 16. Việc nén trước (không phải là một phần của chương trình) đã sử dụng hai bước:

1. Mã hóa độ dài chạy của ma trận đọc theo thứ tự hàng lớn (đầu tiên là sau đó, sau đó xuống).
2. Độ dài đường chạy kết quả nằm trong khoảng từ 1 đến 16, do đó, vectơ độ dài đường chạy trừ 1 đã được chuyển đổi từ cơ sở 16 sang cơ sở 94 (để sử dụng tất cả các mã ASCII có thể in trừ trích dẫn đơn, không được sử dụng vì nó sẽ cần thoát).

Chuỗi nén,

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

được giải nén từ cơ sở 94 đến cơ sở 16:

                                   F16Za

Vectơ thu được của run-lenghts cộng 1 được nhân với 2:

                                        QE

để thực hiện kéo dài ngang.

Vectơ của run-lenghts chứa 49 giá trị. Các số ban đầu được lặp lại với các độ dài đó phải là [0 1 0 1 ... 0](49 mục). Nhưng thay vào đó, việc sử dụng vectơ [1 2 ... 49]sẽ ngắn hơn , sẽ có giá trị như nhau nhờ lập chỉ mục mô-đun. Vì vậy, giải mã độ dài chạy là

49:                                       Y"

Các vector tạo containis chạy của 1, 2, ... 49, với tổng số 512 mục. Điều này được định hình lại thành ma trận 16 × 32:

                                            32e!

và được sử dụng như các chỉ số mô-đun vào chuỗi ' #'để tạo ra một quả bom duy nhất:

                                                ' #'w)

Cuối cùng, sự lặp lại theo chiều ngang bởi một yếu tố được đưa ra bởi đầu vào tạo ra kết quả mong muốn:

                                                      liX"

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

Nó ở ideone

(Tôi nhận ra rằng mã hóa trực tiếp của bom ban đầu trong cơ sở 36 được tạo cho mã ngắn hơn bằng Python.)

Chuỗi được hình thành bằng cách xử lý các khoảng trắng là 1 và băm là 0 và sau đó chuyển đổi sang cơ sở 36. Sau đó, chương trình chuyển đổi trở lại thành nhị phân và lát thành độ dài 16 (với độ lệch là 2 cho '0b' ở phía trước của Python chuỗi nhị phân), chuyển đổi thành không gian kép và băm kép, nối chúng lại, lặp lại nthời gian chuỗi và in.

Trước: 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

Nó ở ideone

Gần như một cổng của câu trả lời Jelly của tôi .

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 được viết dưới dạng nhị phân với 1 cho không gian, đầu 1 loại bỏ sự cần thiết phải đệm các biểu diễn nhị phân. Bom được hoán chuyển (giống như trong câu trả lời của tôi về CJam ) và được lưu trữ trong căn cứ 36.

Chương trình giải mã quả bom thành nhị phân và lặp lại các bit theo bước 16 một cách hiệu quả sau khi chuyển vị (giúp tiết kiệm byte qua việc cắt một dòng nhất định). Dòng kết quả được nối, các bit được thay thế bằng cách nhân đôi hoặc #và nối vào chuỗi singe.

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

Hãy thử trực tuyến!

Được viết dưới dạng một chương trình độc lập ( 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?"##":"  "));}

Hãy thử trực tuyến!

Segfaults này nếu một tham số dòng lệnh không được cung cấp.

Hàng loạt, 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:#=##%

Lưu ý: dòng set s=kết thúc trong 5 khoảng trắng. Chấp nhận số lượng dưới dạng tham số dòng lệnh. Đơn giản chỉ cần vòng qua từng dòng của quả bom (được nén rất nhẹ bằng cách loại bỏ 5 bước chạy giống hệt nhau) sau đó lặp lại quả bom nhiều lần như mong muốn trước khi cuối cùng nhân đôi mỗi nhân vật.

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

Nhìn vào Hex cho danh sách số nhưng dường như nó không tiết kiệm đủ để làm cho nó xứng đáng với nỗ lực. Hy vọng có thể đánh golf xuống mã nhưng dường như đã đi xa hết mức có thể với phương pháp này. Bất kỳ gợi ý bổ sung nhận được biết ơn.

BIÊN TẬP

-1 bằng cách thay đổi e==1thành e>0. Tôi luôn quên điều đó.

-2 bằng cách bỏ qua độ dài của chuỗi nhị phân, nhập trước 7 0 và chỉ lấy 16 phần tử cuối cùng. Hoạt động như không bao giờ có nhiều hơn 7 hàng đầu.

-4 bởi vì bây giờ tôi đã mất tham chiếu thứ hai cho biến b, tôi có thể sử dụng bin(y)[2:]trực tiếp trong chức năng bản đồ lấy nó dưới ma thuật 200 :-)

-8 bằng cách sử dụng phép gán lát trong danh sách thứ hai. Đã học được một cái gì đó mới tối nay.

-3 cảm ơn @Jonathan

-2 bằng cách sử dụng c=d=([0]*7+map(int,bin(y)[2:]))[-16:]thay vì cóc=d;

-2 một lần nữa nhờ @Jonathan

-24 cảm ơn @Linus

Đầu ra

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

RProgN , 210 193 byte

Đã lưu một số byte bằng cách chuyển 0 = '' 1 = '##' thành 1 = '' 0 = '', điều này có nghĩa là tôi không cần thêm các số không trở lại. Ngoài ra, điều này có nghĩa là bây giờ chuỗi B64 được sử dụng để nói "MAFIA" thì không, Điều này thật đáng buồn.

'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

Giải trình

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

Khá dài, Việc mở rộng, in và như vậy của chuỗi nén là 105 byte. Có thể chơi golf nhiều hơn một chút, nhưng ít nhất nó cũng hoạt động.

Đầu vào được ngầm định trên ngăn xếp, ngăn xếp được in ngầm.

Đầu ra

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

Thử nó!

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

Lưu ý: sử dụng mã hóa Windows-1252

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

Chạy như thế này:

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

Hoặc sử dụng mã hóa IBM-850 (135 byte và kết quả đẹp hơn):

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

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

Giải trình

Điều này không làm bất kỳ công cụ nhị phân và không yêu cầu một tập tin bên ngoài.

Mỗi số 16 bit được đảo ngược, sau đó được mã hóa thành số cơ sở 36, được đệm bằng một đầu 0nếu cần thiết, do đó cứ 16 bit sẽ dẫn đến 3 byte. Kết hợp những kết quả trong 01c02203k07d1j81j46b4cmwcmwpa4ohobugc8o6b434w0ow. Mã đảo ngược quá trình để bom được in đúng Nthời gian.

Tinh chỉnh

• Đã lưu 4 byte bằng cách chỉ sử dụng một vòng lặp for
• Đã lưu một byte bằng cách in một char cho mỗi lần lặp và sử dụng chỉ mục chuỗi thay vì ternary
• Đã lưu một byte bằng cách đặt lại $jvề 0 trên ranh giới dòng với %=. Điều này được loại bỏ dấu ngoặc đơn
• Đã lưu 2 byte bằng cách sử dụng $argn

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

Trong một dòng:

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

Chạy với:

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

Biên dịch nguồn dưới dạng ISO8859-x (ASCII).

NB óÿÿþÿoÜüðààÀÀ! ÀCàCðøþ? phải chứa Mã ASCII vô hình nhưng nó đã bị hỏng do cách StackExchange trình bày nội dung của nó. Vui lòng xem liên kết ý tưởng để mã hóa thử nghiệm phù hợp Hoặc Chuỗi ASCII ban đầu có tại: https://github.com/claydonkey/AtariBombs/blob/master/ISO8859_REPR2.txt

Giải trình

Đầu tiên là chuyển đổi đại diện hex của bom [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] sang UTF-8 (trong Phiên bản UTF-8 trình biên dịch lưu trữ chuỗi dưới dạng Wide Char Array - 2 hoặc 4 byte cho mỗi ký tự khi chạy nhưng đây là tính hàn lâm). Trong khi các ký tự UTF-8 sẽ được lưu trữ dưới dạng 2-4 byte, các giá trị này đều nằm trong ISO-8859-1 (ASCII) và do đó chỉ cần 1 byte. Ngoài ra, an toàn khi được lưu trữ dưới dạng ISO-8859-x (không có giá trị 0x8_ hoặc 0x9_). Do đó, văn bản tiêu thụ 32 byte trong ISO-8859 và thường trình tiêu thụ tổng cộng 135 byte.

(Các ký tự rộng NB được lưu trữ dưới dạng số nguyên 16 bit trong windows và 32 bit trong linux nhưng một lần nữa, điều này không liên quan đến nhiệm vụ trong tay)

Hãy cẩn thận: Không phải tất cả các ký tự đều có thể hiển thị (các ký tự điều khiển dưới 0x20). Tuy nhiên, chúng vẫn hiện diện. Hầu hết các trang web là utf-8 / 8859/1253 ( https://w3techs.com/technologists/overview/character_encoding/all ) vì vậy tôi cho rằng điều này là hợp pháp (chuyển tất cả các giá trị dưới 0x20 sang ASCII có thể in được nên khắc phục điều đó).

UTF-8

Đây là phiên bản gần hơn với bài đăng gốc với nguồn được mã hóa UTF-8. Điều này tiêu thụ 173 byte. Chuỗi chính nó là 50 byte của nguồn. Thói quen cũng dài hơn vì các byte ASCII hiện được lưu trữ với phần đệm 0 'cho các ký tự rộng 16 bit / 32 bit và phải được thay đổi thay vì chuyển sang uint16_t như trên. Tôi đã giữ điều này vì nó có thể được xác minh bằng ideone sử dụng mã hóa 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)?"  ":"##")));}

Chạy với:

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

Nếu bạn có thể đặt giá trị ngầm định thành số nguyên 16 bit trong trình biên dịch của mình, bạn có thể bỏ qua khai báo loại wchar_t của Wide Char. Ideone không phàn nàn vì vậy tôi nghĩ rằng nó tốt để đi.

Dùng thử trên ideone

Haskell, 155 byte

Là một hàm với loại 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]]

In trực tiếp lên IO sẽ tốn 5 byte (hoặc 6 nếu chúng tôi muốn quay lại IO ()hơn 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 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("");}}

nối từng x với chính nó và làm cho p tràn để kết thúc mỗi dòng.

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

}

J, 89 byte

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

Mã hóa chuỗi dưới dạng số cơ sở 95, tăng từng chữ số theo 32, sau đó biểu thị chuỗi đó bằng chuỗi ascii.

Giải trình

Điều này bao gồm hai phần chính. Có sự xây dựng của quả bom, và sự lặp lại thực tế. Bây giờ chúng ta hãy nói đến quả bom như b. Sau đó, mã trông như sau:

|:@;@#&(b)

Khi được gọi với đầu vào k, điều này tương đương với:

|: ; (k#b)

b là một quả bom hộp, vì vậy k#b việc klặp đi lặp lại b, ;làm phẳng nó theo chiều dọc và |:hoán chuyển kết quả. (Bom bđược chế tạo chuyển vị.)

Bây giờ, đây là quả bom:

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

Chuỗi sau đây là một chuỗi được mã hóa cơ sở 95 có độ lệch 32, để tất cả các ký tự rơi vào phạm vi ASCII, và may mắn là không có 's nào cần phải thoát. 3 u:lấy mã char của chuỗi, 32x-~làm cho mỗi số trở thành một xsố có xu hướng và trừ đi 32từ đó; 95#.chuyển đổi thành số cơ sở 95 và 2#.invchuyển đổi nó thành mảng số nhị phân. Tôi đã thêm một bản đồ hàng đầu1 đến nhị phân để làm cho nó thành một số vững chắc, vì vậy tôi bỏ nó đi }.. Tôi định hình mảng thành một bảng 16x16 và 16 16$sau đó hoán chuyển nó bằng cách sử dụng |:. (Golf có thể để sau này: hoán chuyển chuỗi được mã hóa theo nghĩa đen.) 2#Sao chép từng chiều rộng của ký tự. Chúng tôi còn lại một bảng 0s và 1s.' #'{~0 s đến ' 'và 1đi '#'. Như vậy, chúng ta bị bỏ lại với quả bom của chúng tôi.

Trường hợp thử nghiệm

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

BaCon , 229 227 195 byte

Một đóng góp trong BASIC vì nỗi nhớ. Biến số 'a' xác định số lượng 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}

Đầu ra :

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

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

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

Cái này sử dụng bitmap bom từ ROM ROM, hơi khác so với cái trong câu hỏi. Đối với các phiên bản khác của TOS, bạn sẽ phải điều chỉnh địa chỉ được chỉ theo *a. Lưu ý rằng một số rom giả lập không bao gồm bitmap bom!

Nếu bạn không cung cấp đối số dòng lệnh, một số quả bom bitmap có độ phân giải cao có thể được hiển thị :-)

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

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

(Ảnh chụp màn hình của phiên bản không có ký tự nhân đôi)
SB có phông chữ vuông, do đó, nhân đôi các ký tự trông có vẻ xấu (và không phù hợp trên màn hình)
Các ký tự không phải ASCII đã được thay thế bằng x.
Giá trị hex: 0008,0002,0610,1F8A,3FC1,7FC1,7FF2,FFF4,FFF8,EFF0,73F0,7FC0,3FC0,1F80,0600
Vì SB lưu tệp trong UTF-8, một số trong số này được tính là 2 hoặc 3 byte.

Ruby 2.x (lambda) - 157 byte

Có thể chơi golf xa hơn, nhưng tôi thích phiên bản này:

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

Ý tưởng tương tự như (các) phiên bản python: phá vỡ chuỗi bom được mã hóa thập lục phân thành các phần gồm 4 ký tự, chuyển đổi thành nhị phân, dịch 1sang #và 0sang , tăng gấp đôi mỗi nhân vật, và in các mảng kết quả.

Lưu ý rằng đặt được sử dụng để in mảng. Điều này sẽ in mảng ra một dòng trên mỗi phần tử.

VBA Excel, 204 byte

VBE ẩn danh Chức năng cửa sổ tức thời lấy đầu vào từ phạm vi [A1]và đầu ra cho Đối tượng 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

Đầu ra