前書き

アタリSTは、モトローラ68000マイクロプロセッサを搭載し早期に90の時代に半ば80年代からかなり人気のパーソナルコンピュータでした。このマシンでは、キャッチされていないCPU例外に対するオペレーティングシステムのデフォルトの動作は、次の図に示すように、画面に爆弾の列を表示することでした。

_{出典：https : //commons.wikimedia.org/wiki/File : Row_of_bombs.png
注意：OSのバージョンによって、爆弾のグラフィックは若干異なる場合があります。しかし、これを参考にしてみましょう。}

爆弾の数は例外ベクトルに依存し、最も一般的なものは次のとおりです。

• （$ 008）バスエラー：2爆弾
• （$ 00c）アドレスエラー：3爆弾
• （$ 010）違法な指示：4爆弾

ゴール

あなたの目標は、このようなAtari ST爆弾のASCIIアートを印刷または出力するプログラムまたは関数を作成することです。

入力

表示する爆弾の数を表す整数。コードは最も一般的な値である2、3、4をサポートする必要があります。サポートする爆弾の数を減らしたり増やしたりするのは問題ありませんが、ボーナスは必要ありません。

出力

元の爆弾は16x16ピクセルのタイルで構成され、ASCIIとバイナリの両方でここに表されます。

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

この課題では、レンダリングを改善するために、各ASCII爆弾を元の幅の2倍に引き伸ばす必要があります。したがって、##「ON」ピクセルに「OFF」ピクセルに2つのスペースを使用して、32文字の16行で構成されます。すべての爆弾タイルを並べて配置する必要があります。先行スペースは禁止されています。末尾のスペースも禁止されていますが、実際に存在しなければならない爆弾タイルの一部（31列目と32列目）を除きます。含めることができるのは、先頭の改行と末尾の改行のみです。

例

以下は2つの爆弾の参照出力です。必須の改行はとしてマークされ\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バイト-文字を2倍にするのを忘れた

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

TryItOnline

どうやって？

準備は、元の画像のランレングスエンコーディングとしてデータを圧縮することでした。

• イメージ内の1s（スペース）または0s（ハッシュ）の各実行の長さをカウントし、改行を無視して、リストを生成します[4,2,11,1,1,...]。
• 各数から1を引く-これにより、範囲が得られ[0,15]ます。
• これを基数16として扱います（vインデックスiを逆にして、値を列挙し、合計16**i*v= 19468823747267181273462257760938030726282593096816512166437）;
• これをbase-250に変換し[5,119,249,42,...]ます。
• Jellyのコードページにインデックスとしてマップします。 ¥vẏ)X;ndĊɓ¡ẹ3ċi}Ịɲ¡P

これで、コードはこの数を評価し、1sと0sをスペースとハッシュ文字にマップし*、それぞれを2倍にして、行に分割し、それぞれ適切な回数繰り返します。
*実際には、実装はバイトを節約するために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文字のみで構成されているため、2進数として表すことができます。
すべての行は同じ長さなので、改行は無視できます。
すべての行で同じなので、各行の最後の文字は無視できます。
使用するスペースが少なく、後で各文字を簡単に複製できるため、より薄い画像を使用します。

1を使用してスペースを表し、0を使用して＃を使用して、2進数を取得します。

111100111111111101011011111111111111101111111011011110111111110111000001111111111000001111111100000000011111000000000001111000000000001110000000000000110000000010000111000000010001111000000100001111100000000011111110000000111111111100011111

次に、これを基数10に変換し、05AB1Eの最大基数である基数214に圧縮します。この結果は次のとおりです。

•ø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バイト

コードには印刷できない文字が含まれているため、ここにリバーシブルのxxd16進ダンプがあります。

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で始まるため）。次に、それをcharに変換し、結果の文字を連結します。

解凍するには、文字コードを抽出し、そのバイナリ表現をハッシュとスペースの文字列に変換する必要があります。これは、次のような再帰関数を使用して実行できます。

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

fの最後のビットを繰り返し使用し、q1の場合は2つのスペースを選択し、0の場合は2つのハッシュを選択fし、残りので実行した結果と連結しqます。これはで実行されx.charCodeAt()、文字コードをスペースとハッシュの正しい文字列に変換します。

（以前はもっと多くのドラマがありましたが、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バイト

OK。50バイトを超えることができないので、楽しみのためだけに...

DOSboxおよび仮想マシンのMS-DOS 6.22で試してみました。

DOSboxではプログラムは正常に動作しますが、実際のMS-DOSでは、DOSは行末にLFではなくCR-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つ +爆弾の数（1〜9）

Python、223 179バイト

2番目のアプローチ：

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で試してみてください！

オンザフライで文字列のリストを作成するのではなく、ハードコードされた16進数文字列があり、インデックスが付けられてバイナリに変換されます。その後、各2進数字は' 'またはに変換され、'#'複製されて結合されます...など。

最初のアプローチ：

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つの爆弾を表示。最後の4つの1は、印刷する爆弾の数の単項表現に置き換えることができます（2は11、3は111）。

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

オンラインでお試しください！

入力を10進数にする必要がある場合、次の値は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スペースを
意味するsは4スペースを
意味する*は6スペースを
意味するqは8スペースを
意味するTは##（2）
tは####（4）
^は#####を意味する＃（6）
rは########（8）を
意味し、##################を意味します（16）
ほとんどのコードは、爆弾が印刷されることを確認しています隣り合わせではなく、互いの上にありません。

CJam、66バイト

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

オンラインでお試しください！ （コードには印刷できない文字があることに注意してください。）

爆弾は、スペースに1を使用してバイナリの数値としてエンコードされ（先頭のスペースは1であるため、バイナリ表現をパディングする必要はありません）、転置され、ベース136の文字列に変換されます（最短の文字列が生成されます）ワイド文字なし）。これらのステップはここで遊ぶことができます。

この答えはエンコードを逆にします。主なトリックは、転置する前に爆弾を繰り返し、爆弾の各行を一度に効果的に連結することです。各行の文字は、最終出力用に改行を挿入して2倍にできます。

PHP、138 104 + 32 = 136バイト

私はそれfileがバイナリ安全だと思ったことはありませんでした。データを保存するより興味深い方法を見つけていただければ幸いです。しかし、私は生のバイナリを打ち負かそうとしませんでした。

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

• ファイルからバイナリデータを読み取り、リトルエンディアンの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バイナリマトリックスのバージョンを使用します。事前圧縮（プログラムの一部ではない）では、2つのステップを使用しました。

1. 行優先順（最初は横方向、次に下方向）に読み取られる行列のランレングスエンコーディング。
2. 結果のランレングスの範囲は1から16であるため、ランレングスから1を引いたベクトルはベース16からベース94に変換されました（エスケープが必要なため使用されない単一引用符を除くすべての印刷可能なASCIIコードを使用します）。

圧縮された文字列、

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

ベース94からベース16に解凍されます。

                                   F16Za

得られたrun-lenghtsのベクトルに1を加えたものに2を掛けます。

                                        QE

水平ストレッチを実行します。

run-lenghtsのベクトルには49個の値が含まれています。これらの長さで繰り返される元の番号は[0 1 0 1 ... 0]（49エントリ）である必要があります。しかし、その代わりに、vectorを使用する方が短くなります[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

それはATのideone

（ベース36の元の爆弾を直接エンコードすると、Pythonのコードが短くなります。）

文字列は、スペースを1として、ハッシュを0として処理してから、ベース36に変換します。その後、プログラムはバイナリに変換し、16の長さにスライスします（Pythonの前面の '0b'のオフセット2バイナリ文字列）、ダブルスペースとダブルハッシュに変換し、それらを結合し、文字列を繰り返してn出力します。

前：Python 2、169 166 163バイト

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

それはATのideone

私のゼリー答えのほとんど移植。

パイソン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 answerのように）、ベース36に保存されます。

プログラムは、爆弾をバイナリにデコードし、16のステップで効果的にビットを繰り返します。結果の行は連結され、ビットはdoubled または#に置き換えられ、単一の文字列に結合されます。

C（gcc）、216204183165134バイト

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

オンラインでお試しください！

コマンドラインパラメーターが指定されていない場合、このセグメンテーション違反が発生します。

バッチ、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つの同一の文字の実行を削除することによって非常にわずかに圧縮されます）、最後に各文字を複製する前に必要な回数だけ爆弾を繰り返します。

パイソン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への2番目の参照を失ったためbin(y)[2:]、マジック200未満でマップ関数で直接使用できるようになりました:-)

-8、2番目のリストのスライス割り当てを使用します。今晩何か新しいことを学びました。

-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 = ''に切り替えていくつかのバイトを保存しました。つまり、余分なゼロを追加する必要はありません。また、これは、「MAFIA」と言っていたB64文字列が現在サポートしていないことを意味します。

'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ビット数が反転され、その後0、必要に応じて先頭が埋め込まれたbase-36数としてエンコードされるため、16ビットごとに3バイトになります。それらの結果を連結し01c02203k07d1j81j46b4cmwcmwpa4ohobugc8o6b434w0owます。コードはプロセスを逆にして、爆弾が正しく印刷されるようにしNます。

微調整

• 単一のforループのみを使用して4バイトを節約
• 反復ごとに1つの文字を出力し、3進数の代わりに文字列インデックスを使用して、1バイトを保存しました
• $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)?"  ":"##");
}

1行で：

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文字列は次の場所にあり ます。

説明

最初に、爆弾の16進表現[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_の値はありません）。したがって、テキストはISO-8859で32バイトを消費し、ルーチンは合計で135バイトを消費します。

（NBワイド文字は、Windowsでは16ビット整数として、Linuxでは32ビットとして格納されますが、これも手元のタスクとは無関係です）

警告：すべての文字が表示可能というわけではありません（0x20未満の制御文字）。ほとんどのWebページはutf-8 / 8859/1253（https://w3techs.com/technologies/overview/character_encoding/all）であるため、これは合法であると考えています（0x20未満のすべての値を印刷可能なASCIIに変更することで修正できます）。

UTF-8

以下は、UTF-8でエンコードされたソースを使用した元の投稿に近いバージョンです。これは173バイトを消費します。文字列自体はソースの50バイトです。ASCIIビットは16ビット/ 32ビットワイド文字のパディング0で保存されるため、ルーチンも長くなり、上記のようにuint16_tにキャストする代わりにシフトする必要があります。UTF-8エンコーディングを使用するideoneで検証できるため、これを維持しました。

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

コンパイラで暗黙的な値を16ビット整数に設定できる場合は、ワイド文字のwchar_t型宣言を省略できます。イデオンは文句を言わないので、行くのは良いことだと思います。

それを試してみてくださいに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バイト（またはIO ()でなく返りたい場合は6バイト）かかります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')

文字列をbase-95番号としてエンコードし、各桁をでインクリメント32し、ASCII文字列で表します。

説明

これは2つの主要部分で構成されています。爆弾の構築と実際の繰り返しがあります。とりあえず、爆弾をとして参照しましょうb。次に、コードは次のようになります。

|:@;@#&(b)

input kで呼び出された場合、これは次と同等です：

|: ; (k#b)

bは箱入りの爆弾なのでk#b、のk繰り返しを行いb、;それを垂直方向に平坦化し|:、結果を転置します。（爆弾b自体は転置して構築されます。）

さて、ここに爆弾があります：

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

以下の文字列は、オフセットがのbase-95でエンコードされた文字列である32ため、すべての文字がASCIIの範囲に収まり、ありがたい'ことにエスケープする必要のある文字はありません。3 u:文字列の文字コードを取得し、32x-~各数値をe x傾向の数値にし、32そこから減算します。95#.95を底とする数値に2#.inv変換し、それを2進数配列に変換します。1バイナリにリードを追加して、それを堅実な数にしたので、で削除し}.ます。配列を16x16テーブルに整形し、16 16$を使用して転置し|:ます。（後のゴルフの可能性：エンコードされたリテラル文字列を転置します。）2#各文字を幅方向に複製します。0sと1sのテーブルが残っています。' #'{~マップ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バイト

懐かしさのためのBASICでの貢献。変数「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}

出力：

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

ハスケル、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。一部のエミュレーターROMには爆弾ビットマップが含まれていないことに注意してください！

コマンドライン引数を提供しない場合、いくつかの高解像度ビットマップ爆弾が表示される場合があります:-)

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には正方形のフォントがあるため、文字を2倍にすると見た目が悪くなります（画面に収まりません）
非ASCII文字はx'sに置き換えられました。
16進値：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}}

Pythonバージョンと同様のアイデア：16進数でエンコードされた爆弾の文字列を4文字のセクションに分割し、バイナリに変換し、変換1します#と0し、二重すべての文字、得られた配列を印刷します。

putsは配列の印刷に使用されることに注意してください。これにより、要素ごとに1行で配列が出力されます。

Excel VBA、204バイト

範囲から入力を[A1]取得し、ActiveSheetオブジェクトに出力する匿名VBEイミディエイトウィンドウ関数

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

出力