บทนำ

Atari STเป็นคอมพิวเตอร์ส่วนบุคคลที่ได้รับความนิยมค่อนข้างตั้งแต่กลางเดือน 80 ถึงต้นยุค 90 ของพลังงานจากโมโตโรล่า 68000 ไมโครโปรเซสเซอร์ บนเครื่องนี้พฤติกรรมเริ่มต้นของระบบปฏิบัติการสำหรับข้อยกเว้นของ CPU ที่ไม่ถูกตรวจจับคือการแสดงแถวของระเบิดบนหน้าจอดังแสดงในภาพต่อไปนี้:

_{ที่มา: https://commons.wikimedia.org/wiki/File:Row_of_bombs.png
หมายเหตุ: กราฟิกระเบิดอาจแตกต่างกันเล็กน้อยขึ้นอยู่กับเวอร์ชั่นของระบบปฏิบัติการ แต่ลองดูอันนี้เป็นข้อมูลอ้างอิง}

จำนวนระเบิดขึ้นอยู่กับข้อยกเว้นเวกเตอร์วัตถุที่พบมากที่สุดคือ:

• ($ 008) ข้อผิดพลาดของบัส: 2 ระเบิด
• ($ 00c) ที่อยู่ผิดพลาด: 3 ครั้ง
• ($ 010) คำสั่งที่ผิดกฎหมาย: 4 ลูก

เป้าหมาย

เป้าหมายของคุณคือการเขียนโปรแกรมหรือฟังก์ชั่นที่พิมพ์หรือแสดงผล ASCII ของระเบิด Atari ST ดังกล่าว

อินพุต

จำนวนเต็มแทนจำนวนระเบิดที่จะแสดง รหัสของคุณจะต้องรองรับค่าที่พบบ่อยที่สุด: 2, 3 และ 4 การสนับสนุนการวางระเบิดน้อยลงและ / หรือมากกว่านั้นใช้ได้ แต่ก็ไม่จำเป็นหรือไม่ต้องมีโบนัส

เอาท์พุต

ระเบิดดั้งเดิมประกอบด้วยไทล์ 16x16 พิกเซลแสดงที่นี่ทั้งใน ASCII และไบนารี:

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

ในการท้าทายนี้ระเบิด ASCII แต่ละลูกจะต้องยืดออกเป็นสองเท่าของความกว้างดั้งเดิมเพื่อการเรนเดอร์ที่ดีขึ้น ดังนั้นจะประกอบด้วย 16 แถวของอักขระ 32 ตัวใช้##สำหรับพิกเซล 'ON' และเว้นวรรคสองพิกเซลสำหรับ 'ปิด' ไพ่ระเบิดทั้งหมดจะต้องวางเคียงข้างกัน ห้ามเว้นวรรคนำหน้า ห้ามเว้นวรรคตามหลังยกเว้นส่วนที่เป็นส่วนหนึ่งของแผ่นวางระเบิด (เช่นคอลัมน์ที่ 31 และ 32) ซึ่งจะต้องมีอยู่ คุณอาจรวมการขึ้นบรรทัดใหม่ไม่เกินหนึ่งครั้งและไม่เกินหนึ่งการขึ้นบรรทัดใหม่

ตัวอย่าง

ด้านล่างนี้เป็นเอาท์พุทอ้างอิงสำหรับการวางระเบิดสองครั้งโดยมีการทำเครื่องหมายแบ่งบรรทัดบังคับ\nและยอมรับการแบ่งบรรทัดเสริมที่ทำเครื่องหมายเป็น(\n):

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

(แน่นอนว่ารูปแบบตัวแบ่งบรรทัดอื่น ๆ เช่น\rหรือ\r\nอาจใช้เช่นกัน)

กฎระเบียบ

นี่คือรหัสกอล์ฟดังนั้นคำตอบที่สั้นที่สุดในหน่วยไบต์ชนะ ช่องโหว่มาตรฐานเป็นสิ่งต้องห้าม

เจลลี่ , 43 44 ไบต์

+1 byte - ลืมที่จะเพิ่มตัวละครเป็นสองเท่า (ไม่ใช่ทุกคนที่สังเกตเห็น!)

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

TryItOnline

อย่างไร?

การเตรียมการคือการบีบอัดข้อมูลเป็นการเข้ารหัสความยาวของภาพต้นฉบับ:

• นับความยาวของการวิ่งแต่ละครั้งของ1s (ช่องว่าง) หรือ0s (แฮช) ในภาพโดยไม่สนใจบรรทัดใหม่ - ให้รายการ: [4,2,11,1,1,...];
• ลบหนึ่งตัวจากแต่ละหมายเลข - สิ่งนี้จะให้ช่วงของ[0,15];
• ปฏิบัติต่อสิ่งนี้เป็นตัวเลขฐาน 16 (แจกแจงค่าvโดยมีดัชนีiอยู่ในสิ่งที่ตรงกันข้ามและสรุปรวม16**i*v= 19468823747267181273462257760938030726282593096816512166437)
• แปลงนี้ไปยังฐาน-250: [5,119,249,42,...];
• แม็พเข้ากับโค้ดเพจของ Jelly เป็นดัชนี: ¥vẏ)X;ndĊɓ¡ẹ3ċi}Ịɲ¡P

ตอนนี้โค้ดจะประเมินตัวเลขนี้แล้วจับคู่อักขระ1s และ0s กับช่องว่างและอักขระแฮช *, เพิ่มแต่ละคู่เป็นสองเท่าแยกออกเป็นเส้นและทำซ้ำแต่ละครั้งตามจำนวนครั้งที่เหมาะสม
* อันที่จริงการใช้งานนั้นถูกดำเนินการแบบโมดูโล 2 เพื่อบันทึกไบต์ดังนั้นช่องว่างจึงเป็นเลขคี่และแฮชคือ:

“¥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 ไบต์

ใช้การเข้ารหัสCP-1252

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

ลองออนไลน์!

คำอธิบาย

ในขณะที่ภาพออกมีเพียง 2 ตัวอักษรเราจึงสามารถแสดงเป็นเลขฐานสอง
เราสามารถละเว้นบรรทัดใหม่เนื่องจากทุกบรรทัดมีความยาวเท่ากัน
เราสามารถละเว้นอักขระตัวสุดท้ายของแต่ละแถวเหมือนกันสำหรับแถวทั้งหมด
เราใช้ภาพที่บางลงเนื่องจากใช้เนื้อที่น้อยลงและเราสามารถทำซ้ำอักขระแต่ละตัวได้ในภายหลัง

ใช้1เพื่อเป็นตัวแทนของพื้นที่และ0เพื่อเป็นตัวแทน#เราได้รับเลขฐานสอง:

111100111111111101011011111111111111101111111011011110111111110111000001111111111000001111111100000000011111000000000001111000000000001110000000000000110000000010000111000000010001111000000100001111100000000011111110000000111111111100011111

จากนั้นเราแปลงค่านี้เป็นฐาน -10 จากนั้นบีบอัดให้เป็นฐาน 214 ซึ่งเป็นฐานสูงสุดใน 05AB1E ผลลัพธ์ของสิ่งนี้คือ:

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

เนื้อของโปรแกรมนั้นประกอบด้วยสิ่งต่อไปนี้:

<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 ไบต์

รหัสมีอักขระที่ไม่สามารถพิมพ์ได้ดังนั้นนี่คือxxdhexdump ที่สามารถย้อนกลับได้

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

ลองออนไลน์

JavaScript (ES6), 159 154 140 136 ไบต์

จำนวนไบต์ที่บันทึกไว้ต้องขอบคุณ @Hedi และ @Arnauld

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

นั่นคือ 104 ตัวอักษร แต่ (น่าเศร้า) 136 UTF-8 ไบต์ สตริงถูกสร้างขึ้นด้วยตัวอย่างนี้:

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

การใช้.replaceแทนที่จะ[...string].mapมีความยาวเท่ากัน:

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

มันทำงานอย่างไร

เนื่องจากแต่ละแถวของข้อมูลดิบสามารถแสดงเป็นตัวเลข 16 บิตเราจึงสามารถเก็บไฟล์ทั้งหมดในสตริง 16 อักขระ อัลกอริทึมการบีบอัดใช้เวลาแต่ละแถวไบนารีพลิกแล้วพลิกกลับ (ตั้งแต่ทุกแถวในต้นฉบับสิ้นสุดใน0ทุกแถวในเวอร์ชันที่แก้ไขตอนนี้เริ่มต้นด้วย1 ) จากนั้นเปลี่ยนเป็นอักขระและเชื่อมอักขระที่เกิดขึ้นพร้อมกัน .

ในการขยายมันเราต้องทำการแยก charcode และเปลี่ยนการแสดงไบนารี่เป็นสายอักขระของแฮชและช่องว่าง สิ่งนี้สามารถทำได้ด้วยฟังก์ชั่นวนซ้ำดังนี้:

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

fซ้ำแล้วซ้ำอีกจะใช้เวลาบิตสุดท้ายของqการเลือกสองช่องว่างถ้าเป็น 1 หรือสอง hashes ถ้าเป็น 0 แล้วเชื่อมกับผลของการทำงานในส่วนที่เหลือของf qสิ่งนี้ทำงานอยู่x.charCodeAt()ทำให้ char-code กลายเป็นสตริงของช่องว่างและแฮชที่ถูกต้อง

(ก่อนหน้านี้มีละครเยอะขึ้น แต่เทคนิคการประหยัด 4 ไบต์ลบทั้งหมดนั่น)

หลังจากนั้นเราก็สามารถทำซ้ำnครั้งสตริงและเพิ่มขึ้นบรรทัดใหม่ นี่เป็นวิธีการคลายการบีบอัดที่สั้นที่สุดที่ฉันพบ แต่อย่าลังเลที่จะแนะนำวิธีที่สั้นกว่านี้

ความพยายามอื่น ๆ ในการบีบอัดสตริง:

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

ครั้งแรกของเหล่านี้คือ 153 ไบต์จึงไม่มีใครมาใกล้ 136 ...

ไฟล์ MS-DOS .COM ขนาด 84 ไบต์

ตกลง. เพื่อความสนุกเพราะฉันไม่สามารถเอาชนะ 50 ไบต์ ...

พยายามภายใต้ DOSbox และ MS-DOS 6.22 ในเครื่องเสมือน

ภายใต้ DOSbox โปรแกรมทำงานได้ดี แต่จริงภายใต้ MS-DOS เอาต์พุตจะไม่แสดงอย่างถูกต้องเพราะ DOS ต้องการ CR-LF แทน LF ที่ปลายบรรทัด

(อย่างไรก็ตามผลลัพธ์ถูกต้อง)

ตัวแปร 88 ไบต์จะใช้ CR-LF ที่ส่วนท้ายของบรรทัด

นี่คือไฟล์:

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

รหัสแอสเซมเบลอร์ (ในไวยากรณ์ AT&T) มีลักษณะดังนี้:

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

--- แก้ไข ---

ฉันลืมที่จะพูดถึง: โปรแกรมจะต้องเริ่มต้นด้วยบรรทัดคำสั่งต่อไปนี้:

ชื่อของไฟล์ COM + ตัวอักษรเว้นวรรคหนึ่งตัว + จำนวนระเบิด (1-9)

Python 223 179 ไบต์

แนวทางที่สอง:

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

ลองใช้กับ repl.it!

แทนที่จะสร้างรายการของสตริง on-the-fly มีสตริงเลขฐานสิบหกแบบตายตัวซึ่งมีการจัดทำดัชนีและแปลงเป็นไบนารี จากนั้นแต่ละเลขฐานสองก็กลายเป็นอย่างใดอย่างหนึ่ง' 'หรือ'#'ซึ่งซ้ำกันและเข้าร่วมกัน ... ฯลฯ

วิธีแรก:

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

ลองใช้กับ repl.it!

สิ่งนี้มีรายการรหัสตายตัวของสตริงของแต่ละบรรทัด (ไม่รวมช่องว่างต่อท้าย) ที่สร้างขึ้นโดยการทำซ้ำอย่างใดอย่างหนึ่ง' 'หรือ'##'หลายครั้ง สำหรับแต่ละสตริงเหล่านี้จะมีการเว้นวรรคจนกว่าจะมีความยาว 32 อักขระซ้ำกันnแล้วรวมเข้ากับการขึ้นบรรทัดใหม่

C, 250 240 208 188 ไบต์

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

สลับไปใช้ฟังก์ชั่น

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

ทดสอบอย่างนี้ main(c,v)char**v; { f(atoi(v[1])); }

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

/// , 539 532 + หมายเลข ของไบต์ระเบิด

คำตอบ /// คำตอบแรกแสดง 4 ระเบิด สามารถแทนที่สี่ท้าย 1 ด้วยการแสดงจำนวนระเบิดที่คุณต้องการพิมพ์ (11 สำหรับ 2, 111 สำหรับ 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

ลองออนไลน์!

หากอินพุตต้องเป็นทศนิยมข้อมูลต่อไปนี้มี555 548 ไบต์ (ซึ่งตัวเลขหลักสุดท้ายสามารถเปลี่ยนเป็น 1, 2, 3 หรือ 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

ลองออนไลน์!

ส่วนที่สำคัญที่สุดของรหัสคือ:
| หมายถึง //
ABCDEFGHIJKLMNOP หมายถึงแต่ละบรรทัดของระเบิดตามลำดับ
S หมายถึง 2 ช่องว่าง
หมายถึง 4 ช่องว่าง
* หมายถึง 6 ช่องว่าง
q หมายถึงช่องว่าง 8 หมายถึง 8 ช่องว่าง
T หมายถึง ## (2)
t หมายถึง #### (4)
^ หมายถึง ##### # (6)
r หมายถึง ######## (8)
& หมายถึง ################ (16)
รหัสส่วนใหญ่ทำให้แน่ใจว่ามีการพิมพ์ระเบิด เคียงข้างกันไม่ได้อยู่ด้านบนของกันและกัน

CJam , 66 ไบต์

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

ลองออนไลน์! (โปรดทราบว่ามีอักขระที่ไม่สามารถพิมพ์ได้บางส่วนในรหัส)

ระเบิดที่ถูกเข้ารหัสเป็นเลขฐานสองในการใช้ 1 สำหรับช่องว่าง (พื้นที่ชั้นนำเป็น 1 ทำให้แน่ใจว่าเราไม่จำเป็นต้องวางแผ่นเลขฐานสองแทน) ย้ายจากนั้นแปลงเป็นสตริงในฐาน -136 (ซึ่งสร้างสตริงที่สั้นที่สุด ไม่มีตัวอักษรกว้าง) ขั้นตอนเหล่านี้สามารถเล่นได้กับที่นี่

คำตอบนี้จะสลับการเข้ารหัสเคล็ดลับหลักคือการทำระเบิดซ้ำก่อนที่จะทำการย้ายการประสานอย่างมีประสิทธิภาพในแต่ละบรรทัดของการระเบิดในครั้งเดียว อักขระในแต่ละบรรทัดนั้นสามารถเพิ่มเป็นสองเท่าด้วยการขึ้นบรรทัดใหม่สำหรับผลลัพธ์สุดท้าย

PHP, 138 104 + 32 = 136 ไบต์

ฉันไม่เคยคิดเลยว่าfileมันปลอดภัยไบนารี่ ฉันหวังว่าฉันจะได้พบวิธีที่น่าสนใจในการจัดเก็บข้อมูลเท่านั้น แต่ไม่มีอะไรฉันพยายามเอาชนะไบนารีดิบ

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

• อ่านข้อมูลไบนารีจากไฟล์แกะออกจาก endian 16 บิตไปยังอาร์เรย์ของ int
• ห่วงผ่านอาร์เรย์: พิมพ์ 16 บาทไบนารีสตริงแทนที่0มี 2 ช่องว่าง1ด้วย##,
  ซ้ำ$argv[1]ครั้งผลการพิมพ์ + ขึ้นบรรทัดใหม่

ทำงานด้วย -r

ข้อมูลไบนารีในไฟล์b:

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

รหัสเพื่อสร้างไฟล์:

$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 ไบต์

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

ลองออนไลน์!

คำอธิบาย

รหัสนี้ใช้ไบนารีเมทริกซ์ 16 × 16 ที่มีการบีบอัดไว้ล่วงหน้า การบีบอัดล่วงหน้า (ไม่ใช่ส่วนหนึ่งของโปรแกรม) ใช้สองขั้นตอน:

1. การเข้ารหัสความยาวรันของเมทริกซ์ที่อ่านตามลำดับแถวที่สำคัญ
2. ผลลัพธ์ความยาวของรันตั้งแต่ 1 ถึง 16 ดังนั้นเวกเตอร์ของความยาวรันลบ 1 จึงถูกแปลงจากฐาน 16 เป็นฐาน 94 (เพื่อใช้รหัส ASCII ที่พิมพ์ได้ทั้งหมดยกเว้นเครื่องหมายคำพูดเดี่ยวซึ่งไม่ได้ใช้เพราะจะต้องหลบหนี)

สตริงที่บีบอัด

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

ถูกคลายการบีบอัดจากฐาน 94 ถึงฐาน 16:

                                   F16Za

เวกเตอร์ที่ได้รับจาก run-lenghts plus 1 คูณด้วย 2:

                                        QE

เพื่อยืดแนวนอน

เวกเตอร์ของ run-lenghts มี 49 ค่า ตัวเลขดั้งเดิมที่จะทำซ้ำกับความยาวเหล่านั้นควรเป็น[0 1 0 1 ... 0](49 รายการ) แต่แทนที่จะเป็นสิ่งนั้นมันสั้นกว่าที่จะใช้เวกเตอร์[1 2 ... 49]ซึ่งจะใช้ได้อย่างเท่าเทียมกันเนื่องจากการทำดัชนีแบบแยกส่วน ดังนั้นการถอดรหัสความยาวรันจึงเป็น

49:                                       Y"

เวกเตอร์ที่สร้าง containis วิ่งของ1, 2... 49รวม 512 รายการ นี่ถูกเปลี่ยนเป็นเมทริกซ์ 16 × 32:

                                            32e!

และใช้เป็นดัชนีแบบแยกส่วนในสตริง' #'เพื่อสร้างระเบิดเดี่ยว:

                                                ' #'w)

ในที่สุดการทำซ้ำแนวนอนโดยปัจจัยที่กำหนดโดยอินพุตสร้างผลลัพธ์ที่ต้องการ:

                                                      liX"

Python 2: 143 ไบต์

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

มันอยู่ที่ideone

(ฉันรู้ว่าการเข้ารหัสโดยตรงของระเบิดดั้งเดิมในฐาน 36 ทำขึ้นเพื่อให้โค้ดสั้นลงใน Python)

สตริงเกิดจากการจัดการช่องว่างเป็น 1s และแฮ็คเป็น 0 แล้วแปลงเป็นฐาน 36 จากนั้นโปรแกรมแปลงกลับเป็นไบนารีและแบ่งส่วนเป็นความยาว 16 (โดยมีออฟเซ็ต 2 สำหรับ '0b' ที่ด้านหน้าของ Python สตริงไบนารี) แปลงเป็นช่องว่างสองครั้งและแฮชสองครั้งเชื่อมเข้าด้วยกันทำซ้ำครั้งของสตริงnและพิมพ์

ก่อนหน้านี้: Python 2, 169 166 163 bytes

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

มันอยู่ที่ideone

เกือบหนึ่งในพอร์ตของคำตอบของฉัน Jelly

Python 2.7, 144 141 ไบต์

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

ระเบิดถูกเขียนด้วยเลขฐานสองโดยมี 1 ช่องว่างส่วนที่ 1 ชั้นนำจะลบความจำเป็นในการเป็นตัวแทนไบนารี วางระเบิดแล้ว (เหมือนในคำตอบ CJam ของฉัน ) และเก็บไว้ในฐาน 36

โปรแกรมถอดรหัสการวางระเบิดเป็นเลขฐานสองและทำซ้ำบิตโดยขั้นตอนที่ 16 อย่างมีประสิทธิภาพหลังจากการขนย้าย บรรทัดผลลัพธ์ถูกต่อกันบิตจะถูกแทนที่ด้วยสองเท่าหรือ#และเข้าร่วมในสตริง singe

C (gcc) , 216 204 183 165 134 ไบต์

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

ลองออนไลน์!

เขียนเป็นโปรแกรมสแตนด์อโลน ( 201 183 151 ไบต์)

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

ลองออนไลน์!

segfaults นี้หากไม่ได้ระบุพารามิเตอร์บรรทัดคำสั่ง

แบตช์ 415 ไบต์

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

หมายเหตุ: บรรทัดset s=สิ้นสุดใน 5 ช่องว่าง ยอมรับการนับเป็นพารามิเตอร์บรรทัดคำสั่ง เพียงแค่วนลูปผ่านแต่ละแถวของการวางระเบิด (บีบอัดเล็กน้อยโดยการลบจำนวนอักขระที่เหมือนกัน 5 ตัว) จากนั้นจะทำการวางระเบิดซ้ำหลาย ๆ ครั้งตามที่ต้องการก่อนที่จะทำซ้ำอักขระแต่ละตัวในที่สุด

Python 2, 206 205 203 199 191 188 186 184 160 ไบต์

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

ดูที่ Hex สำหรับรายการตัวเลข แต่ดูเหมือนว่าจะไม่ประหยัดพอที่จะทำให้คุ้มค่ากับความพยายาม หวังว่าจะสามารถตีรหัสลงได้ แต่ดูเหมือนว่าจะได้รับเท่าที่ฉันสามารถทำได้ด้วยวิธีการนี้ คำแนะนำเพิ่มเติมใด ๆ ที่ได้รับสุดซึ้ง

แก้ไข

-1 โดยการเปลี่ยนไปe==1 e>0ฉันลืมสิ่งนั้นเสมอ

-2 โดยไม่สนใจความยาวของสตริงไบนารีการเตรียม 7 0 และรับเฉพาะองค์ประกอบ 16 รายการสุดท้าย ทำงานได้เนื่องจากไม่มี 0 มากกว่า 7 อันดับแรก

-4 เพราะตอนนี้ฉันสูญเสียการอ้างอิงที่สองไปยังตัวแปร b ฉันสามารถใช้bin(y)[2:]โดยตรงในฟังก์ชั่นแผนที่โดยใช้ด้านล่างเวทย์มนตร์ 200 :-)

-8 โดยใช้การกำหนดชิ้นในรายการที่สอง เรียนรู้สิ่งใหม่เมื่อค่ำนี้

-3 ด้วยขอบคุณ @Jonathan

-2 โดยใช้c=d=([0]*7+map(int,bin(y)[2:]))[-16:]แทนการมีc=d;

-2 ขอบคุณ @Jonathan อีกครั้ง

-24 ด้วยขอบคุณ @Linus

เอาท์พุต

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

RProgN , 210 193 ไบต์

บันทึกเป็นจำนวนไบต์ด้วยการสลับ 0 = '' 1 = '##' ถึง 1 = '' 0 = '' ซึ่งหมายความว่าฉันไม่จำเป็นต้องเพิ่มค่าศูนย์กลับ นอกจากนี้ยังหมายความว่าตอนนี้สตริง B64 ที่เคยพูดว่า "MAFIA" ไม่ได้นี่คือเรื่องน่าเศร้า

'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

คำอธิบาย

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

ค่อนข้างยาวการขยายการพิมพ์และสตริงที่บีบอัดนั้นมีขนาด 105 ไบต์ อาจจะเล่นกอล์ฟได้มากกว่านี้ แต่อย่างน้อยก็ใช้งานได้

อินพุตมีความหมายบนสแต็กสแต็กจะถูกพิมพ์โดยปริยาย

เอาท์พุต

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

ลองมัน!

<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 ไบต์

หมายเหตุ: ใช้การเข้ารหัส Windows-1252

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

ทำงานแบบนี้:

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

หรือใช้การเข้ารหัส IBM-850 (135 ไบต์และผลลัพธ์ที่ดีกว่า):

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

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

คำอธิบาย

นี่ไม่ได้ทำสิ่งไบนารีใด ๆ และไม่ต้องการไฟล์ภายนอก

ทุกหมายเลข 16 บิตจะถูกย้อนกลับจากนั้นเข้ารหัสเป็นหมายเลขฐาน -36 ซึ่งมีเบาะรอง0หากจำเป็นดังนั้นทุก 16 บิตจะส่งผลให้มี 3 ไบต์ การต่อผลลัพธ์เหล่านั้นเข้า01c02203k07d1j81j46b4cmwcmwpa4ohobugc8o6b434w0owด้วยกัน รหัสย้อนกลับกระบวนการเพื่อให้การพิมพ์อย่างถูกต้องNครั้ง

การปรับแต่ง

• บันทึก 4 ไบต์โดยใช้เพียงหนึ่ง for-loop เท่านั้น
• บันทึกเป็นไบต์ด้วยการพิมพ์อักขระเดี่ยวสำหรับการวนซ้ำแต่ละครั้งและใช้ดัชนีสตริงแทนการประกอบ
• ที่บันทึกไว้ไบต์โดยได้รับการตั้งค่าให้เป็นศูนย์ในขอบเขตสอดคล้องกับ$j %=นี่เป็นการกำจัดวงเล็บ
• บันทึก 2 ไบต์โดยใช้ $argn

GCC C 129 ไบต์

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

ในหนึ่งบรรทัด:

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

ทำงานด้วย:

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

รวบรวมแหล่งที่มาเป็น ISO8859-x (ASCII)

NB óÿÿþÿoÜüðààÀÀ! ÀCàCðøþ? ควรมีรหัส ASCII ที่มองไม่เห็น แต่มันเสียเนื่องจากวิธีที่ StackExchange นำเสนอเนื้อหา โปรดดูลิงก์ ideaone สำหรับการเข้ารหัสทดสอบที่เหมาะสมอีกทางหนึ่งหรือสตริง ASCII ดั้งเดิมอยู่ที่: https://github.com/claydonkey/AtariBombs/blob/master/ISO8859_REPR2.txt

คำอธิบาย

ก่อนอื่นการแปลงเลขฐานสิบหกของระเบิด [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] เพื่อ UTF-8 (ในตัว คอมไพเลอร์รุ่น UTF-8 เก็บสตริงเป็น Wide Char Array - 2 หรือ 4 ไบต์สำหรับอักขระแต่ละตัวที่รันไทม์ แต่นี่เป็นเชิงวิชาการ) ในขณะที่อักขระ UTF-8 จะถูกเก็บไว้เป็น 2-4 ไบต์ค่าเหล่านี้ทั้งหมดอยู่ใน ISO-8859-1 (ASCII) ดังนั้นจึงต้องใช้เพียง 1 ไบต์ นอกจากนี้ยังปลอดภัยที่จะถูกเก็บเป็น ISO-8859-x (ไม่มีค่า 0x8_ หรือ 0x9_) ดังนั้นข้อความจึงใช้ 32 ไบต์ใน ISO-8859 และรูทีนนั้นใช้ 135 ไบต์ทั้งหมด

(NB wide chars ถูกเก็บไว้เป็นจำนวนเต็ม 16 บิตใน windows และ 32 บิตใน linux แต่นี่ไม่เกี่ยวข้องกับงานในมือ)

ข้อแม้: ตัวละครทั้งหมดไม่สามารถแสดงได้ (ตัวควบคุมด้านล่าง 0x20) พวกเขามี แต่ยังคงมีอยู่ หน้าเว็บส่วนใหญ่เป็น utf-8 / 8859/1253 ( https://w3techs.com/technologies/overview/character_encoding/all ) ดังนั้นฉันจึงคิดว่านี่เป็นสิ่งที่ถูกต้อง(เลื่อนค่าทั้งหมดต่ำกว่า 0x20 ไปเป็น ASCII ที่พิมพ์ได้ควรแก้ไข)

UTF-8

นี่คือเวอร์ชันที่ใกล้เคียงกับการโพสต์ต้นฉบับด้วยแหล่งที่เข้ารหัส UTF-8 สิ่งนี้ใช้ 173 ไบต์ สตริงเองมีขนาด 50 ไบต์ของแหล่งที่มา รูทีนนั้นยาวกว่าเนื่องจาก ASCII bytes จะถูกเก็บไว้ด้วยการเติม 0 สำหรับ 16 บิต / 32 บิต Wide Chars และจะต้องเลื่อนแทนการ cast ไปเป็น uint16_t ข้างต้น ฉันทำตามนี้เพราะมันสามารถตรวจสอบได้ด้วย ideone ซึ่งใช้การเข้ารหัส 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)?"  ":"##")));}

ทำงานด้วย:

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

หากคุณสามารถตั้งค่า implicit เป็นจำนวนเต็ม 16 บิตใน complier ของคุณคุณสามารถละเว้นการประกาศชนิด wchar_t ของ Wide Char Ideone ไม่บ่นดังนั้นฉันคิดว่ามันเป็นเรื่องดีที่จะไป

ลองใช้กับideone

Haskell, 155 ไบต์

ในฐานะที่เป็นฟังก์ชั่นที่มีประเภท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]]

การพิมพ์ไปยัง IO โดยตรงจะมีราคา 5 ไบต์ (หรือ 6 ถ้าเราต้องการส่งคืนIO ()มากกว่า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 ไบต์

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

เชื่อมต่อแต่ละ x เข้ากับตัวเองและทำให้ p ล้นจนจบแต่ละบรรทัด

Java, 228 ไบต์

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 ไบต์

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

เข้ารหัสสตริงเป็นตัวเลขฐาน 95 เพิ่มทีละหลักด้วย32จากนั้นแทนด้วยสตริง ascii

คำอธิบาย

ประกอบด้วยสองส่วนหลัก มีการสร้างระเบิดและการเกิดซ้ำจริง เรามาดูการวางระเบิดกันในขณะbนี้ จากนั้นรหัสดูเหมือนว่า:

|:@;@#&(b)

เมื่อเรียกด้วยอินพุตkสิ่งนี้เทียบเท่ากับ:

|: ; (k#b)

bเป็นระเบิดชนิดบรรจุกล่องเพื่อk#bทำkซ้ำของb, ;flattens ในแนวตั้งและ|:transposes ผล (ระเบิดbถูกสร้างขึ้นเอง)

ตอนนี้นี่คือระเบิด:

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

สตริงต่อไปนี้เป็นสตริงเข้ารหัสที่ฐาน 95 ซึ่งมีออฟเซ็ต32ดังนั้นอักขระทั้งหมดจะอยู่ในช่วง ASCII และขอบคุณที่ไม่มีค่า'ที่ต้องหลีกเลี่ยง 3 u:รับรหัสถ่านของสตริง32x-~ทำให้แต่ละหมายเลขxมีจำนวนมีแนวโน้มและลบออก32จากมัน 95#.แปลงเป็นเลขฐาน 95 และ2#.invแปลงเป็นเลขฐานสอง ฉันเพิ่มชั้นนำไบนารีเพื่อที่จะทำให้มันเป็นจำนวนที่มั่นคงดังนั้นฉันจะเอามันออกด้วย1 }.ฉันรูปร่างอาร์เรย์ลงในตาราง 16x16 ด้วยแล้วย้ายได้โดยใช้16 16$ |:(กอล์ฟที่เป็นไปได้ในภายหลัง: แปลงสตริงที่เข้ารหัสตามตัวอักษร) 2#ทำซ้ำอักขระไวด์ ธ แต่ละตัว เราจะเหลือโต๊ะ0และ1เอส' #'{~แผนที่0ที่จะ' 'และจะ1 '#'ด้วยเหตุนี้เราจึงถูกทิ้งระเบิดไว้

กรณีทดสอบ

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

BaCon , 229 227 195 ไบต์

มีส่วนร่วมในขั้นพื้นฐานเพื่อประโยชน์ของความคิดถึง ตัวแปร 'a' กำหนดปริมาณของระเบิด

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}

ผลผลิต :

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

Haskell, 191 181 ไบต์

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 (อาตาริ TOS 2.06 US), 129 124 117 113 ไบต์

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

สิ่งนี้ใช้บิตแมปการวางระเบิดจาก TOS ROM ซึ่งแตกต่างจากคำถามในคำถามเล็กน้อย สำหรับรุ่นอื่น ๆ ของ TOS *aคุณจะต้องปรับอยู่ที่ชี้ไปตาม พึงระลึกไว้ว่าอีมูเลเตอร์จำลองบางตัวไม่มีบิตแมปการวางระเบิด

หากคุณไม่ได้ระบุอาร์กิวเมนต์บรรทัดคำสั่งอาจมีการแสดงบิตแมปความละเอียดสูงหลายรายการ :-)

C ++ 11, 252 ไบต์

#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 ไบต์

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

(ภาพหน้าจอของรุ่นที่ไม่มีตัวอักษรสองเท่า)
SB มีแบบอักษรสี่เหลี่ยมดังนั้นตัวละครสองตัวดูไม่ดี (และไม่พอดีกับหน้าจอ)
อักขระที่ไม่ใช่ ASCII ถูกแทนที่ด้วยx's
ค่า Hex: 0008,0002,0610,1F8A,3FC1,7FC1,7FF2,FFF4,FFF8,EFF0,73F0,7FC0,3FC0,1F80,0600
เนื่องจาก SB บันทึกไฟล์เป็น UTF-8 บางส่วนจึงนับเป็น 2 หรือ 3 ไบต์

Ruby 2.x (แลมบ์ดา) - 157 ไบต์

อาจจะสามารถเล่นกอล์ฟต่อไปได้ แต่ฉันชอบรุ่นนี้:

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

ความคิดที่คล้ายกันเป็นรุ่นหลาม (s): ทำลายสตริงของเลขฐานสิบหกเข้ารหัสระเบิดออกเป็นส่วนของ 4 ตัวอักษร, แปลงไบนารีแปล1ไป#และ0ไปสองครั้งตัวละครทุกตัวและพิมพ์อาร์เรย์ที่เกิด

โปรดทราบว่าการวางจะใช้ในการพิมพ์อาร์เรย์ นี้จะพิมพ์อาร์เรย์ออกหนึ่งบรรทัดต่อองค์ประกอบ

Excel VBA, 204 ไบต์

ไม่ระบุชื่อ VBE ฟังก์ชันหน้าต่างทันทีที่รับอินพุตจากช่วง[A1]และผลลัพธ์ไปยังวัตถุ 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

เอาท์พุต