让我们画一些Atari ST炸弹！

47

介绍

在雅达利ST是从80年代中期到90年代初的时代，搭载了摩托罗拉68000微处理器一个相当流行的个人电脑。在这台机器上，未捕获的CPU异常的操作系统的默认行为是在屏幕上显示一行炸弹，如下图所示：

一排炸弹

来源：https ://commons.wikimedia.org/wiki/File : Row_of_bombs.png
注意：取决于操作系统版本，炸弹图形可能会略有不同。但是，让我们以此作为参考。

炸弹的数量取决于异常向量，最常见的是：

  • （$ 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炸弹拉伸到其原始宽度的两倍，以实现更好的渲染。因此，它将由16行32个字符组成，##用于“ ON”像素，两个空格用于“ OFF”像素。所有炸弹砖必须并排放置。禁止前导空格。除必须存在的炸弹块（即第31列和第32列）的一部分之外，也禁止使用尾随空格。您可以包含不超过一个前导换行符和不超过一个尾随换行符。

例

以下是两枚炸弹的参考输出，其中强制性换行标记为\n，容许的额外换行标记为(\n)：

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

（当然，也可以使用其他换行格式，例如\r或\r\n。）

规则

这是代码高尔夫球，因此最短的答案以字节为单位。禁止出现标准漏洞。

code-golf  ascii-art  kolmogorov-complexity 
— Arnauld
source
我注意到您已经排除了非ASCII形式的表格，因此不包括以正确数量的炸弹崩溃的Atari ST机器代码功能。（炸弹不是字体，但是Atari ST的本机字符集中有有趣/复活节彩蛋的字形，包括28-31个字符，它们是4个片断，形成了讽刺教堂的JR“鲍勃”多布斯的形象我记得写过一个程序，该程序在屏幕随机位置上对这 4个字形进行了垃圾处理，这是使用文本绘图系统调用的早期练习：)
— Peter Cordes
1
@PeterCordes-是的，它必须是ASCII。但是，您可以从ST ROM读取炸弹图形，因为没有规则可以阻止您这样做。（只需提及应该使用的TOS版本即可。）
— Arnauld
1
哦，哇，那回想起了。我的第一台计算机是Atari ST。我记得那些炸弹令人恐惧。
— Rod
撇开： “炸弹的数量取决于异常向量”-说什么？！他们为什么无法输出实际的代码/错误有什么原因？（从未有过ST，我来自Amiga营地……“大师冥想”等等。）
— 怀特先生

Answers:

20

果冻，43 44 字节

+1字节-忘记将字符加倍（没有人注意到！）

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

在线试用

怎么样？

准备将数据压缩为原始图像的行程编码：

  • 算的每个游程的长度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
— 乔纳森·艾伦
source
19

05AB1E，57 55 53 50字节

使用CP-1252编码。

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

在线尝试！

说明

由于输出图像仅包含2个字符，因此我们可以将其表示为二进制数。
我们可以忽略换行符，因为每行的长度都相同。
我们可以忽略每行的最后一个字符，因为所有行的字符都相同。
我们使用较薄的图像，因为它占用的空间较小，以后可以轻松复制每个字符。

用1表示空间，用0表示＃，我们得到二进制数：

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
— 艾米尼亚
source
12

Pyth，57 56 54 53 51 50字节

该代码包含不可打印的字符，因此这是一个可逆的xxd十六进制转储。

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

在线尝试。

— PurkkaKoodari
source
11

的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字节。该字符串是使用以下代码段生成的：

显示代码段

使用.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重复使用的最后一位q，如果为1，则选择两个空格；如果为0，则选择两个哈希，然后将其与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个字节附近。

— ETH生产
source
可以节省一些字节，+x?'##':' '而不是" #"[x].repeat(2)
— Hedi
@Hedi谢谢，我知道有一种打高尔夫球的方法。
— ETHproductions
2
您能直接测试的位x.charCodeAt()而不是将其转换为二进制吗？（我认为这样可以节省大约8个字节。）
— Arnauld
2
您的压缩算法听起来几乎是加密的。
— 贾斯汀
1
@Justin Damn，我只是要发表评论。
— user253751 '16
10

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）

— 马丁·罗森瑙
source
1
真好 我们仍然缺少68000的答案，但是这个答案越来越近了。:-)
— Arnauld
objdump -dw输出是显示原始二进制文件的好方法，因为您可以看到哪些字节是哪个指令。我这样做是为了gcd和adler32答案。（以及包括注释的源代码供人们尝试。）
— Peter Cordes
8

Python，223179字节

第二种方法：

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！

除了动态创建字符串列表外，还有一个硬编码的十六进制字符串，它会被索引并转换为二进制。然后将每个二进制数转换为' '或'#'，将其复制并连接在一起...等。

第一种方法：

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两次，然后再添加换行符。

— act
source
您可以通过切换到打印展开的生成器来保存字节，而不是加入'\n'。因此，lambda n:print(*(''.join(2*' #'[int(d)]for d in bin(int('0c0052000100908023e003e00ff81ffc1ffc3ffe3fde1fdc1fbc0ff807f001c0'[i:i+4],16))[2:].zfill(16))*n for i in range(0,64,4)))。另外，您不必计算为lambda分配名称所需的字节数。所以，你的分数可以是176
— 摩根Thrapp
6

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
        ####                            ####                        
  ##  ##    ##                    ##  ##    ##                  
              ##                              ##                    
##    ##        ##              ##    ##        ##              
    ##      ##########              ##      ##########          
            ##########                      ##########          
        ##################              ##################      
      ######################          ######################    
      ######################          ######################    
    ##########################      ##########################  
    ################  ########      ################  ########  
      ##############  ######          ##############  ######    
      ############  ########          ############  ########    
        ##################              ##################      
          ##############                  ##############        
              ######                          ######
— 克莱布朗
source
您可以使用那些十六进制数字的十进制表示形式来保存一些字节，以免丢失0x。
— 铜
@Copper谢谢，我设法也使用put代替putchar剃了不少字节。
— cleblanc
6

///，539532 +号 炸弹字节

第一个///答案，显示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个空格
s表示4个空格
*表示6个空格
q表示8个空格
T表示##（2）
t表示####（4）
^表示##### ＃（6）
r表示########（8）
＆表示############（16）
大多数代码确保印有炸弹并排放置，而不是彼此重叠。

— Boboquack
source
5

CJam，66个字节

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

在线尝试！ （请注意，代码中包含一些不可打印的字符。）

将炸弹以二进制数的形式编码，使用1表示空格（前导空格为1，确保我们不必填充二进制表示形式），进行转置，然后转换为base-136（产生最短的字符串）没有宽字符）。这些步骤可以在此处进行。

然后，这个答案会逆转编码，主要技巧是在转置之前重复炸弹，从而有效地将炸弹的每一行立即连接在一起。然后可以将每行中的字符加倍，并插入换行符以最终输出。

— 莱纳斯
source
5

PHP，138104 + 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);
— 泰特斯
source
2
您可以通过使用前导换行符而不是尾随换行符来节省2个字节，从而在回显之后没有空格，并且可以使用实际的换行符而不是\n。
— user59178 '16
@ user59178我知道。请不要那么冗长。
— 泰特斯（Titus）
5

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

获得的行程长度矢量加1乘以2：

                                        QE

执行水平拉伸。

游程长度向量包含49个值。以这些长度重复的原始编号应为[0 1 0 1 ... 0]（49个条目）。但是相反，使用vector的时间要短一些[1 2 ... 49]，这要归功于模块化索引。所以游程解码是

49:                                       Y"

生成的向量contains是1，，2... 的运行，49总共512个条目。将其重塑为16×32矩阵：

                                            32e!

并用作字符串的模块化索引' #'以产生单个炸弹：

                                                ' #'w)

最后，按输入给定的因子进行水平重复会产生所需的结果：

                                                      liX"
— 路易斯·门多
source
4

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

（我意识到直接在base 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

在ideone

我的果冻答案差不多了。

— 乔纳森·艾伦
source
效率越低越好。尼斯+1
— ElPedro
4

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的步长迭代位（在切片给定行时节省了字节）。将结果行连接起来，将位替换为double 或#，然后将其连接为singe字符串。

— 莱纳斯
source
1
您可以从基数36的数字中删除前导零。
— 乔纳森·艾伦
@JonathanAllan：很好。我认为这是O出于某种原因...
— Linus
4

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

在线尝试！

如果未提供命令行参数，则会出现此段错误。

— 吊顶猫
source
3

批处理，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个相同字符的行将其压缩很小），然后根据需要重复炸弹多次，最后复制每个字符。

— 尼尔
source
3

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

在十六进制中查找了数字列表，但似乎没有节省足够的精力来值得这样做。希望能够精简代码，但似乎已尽我所能。非常感谢您收到的任何其他提示。

编辑

更改e==1为-1 e>0。我总是忘记那个。

-2通过忽略二进制字符串的长度，在7之前加上7，仅接受最后16个元素。可以正常工作，因为前导0不会超过7。

-4因为现在我已经丢失了对变量b的第二个引用，所以我可以bin(y)[2:]直接在map函数中使用它，使其低于魔法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
        ####                            ####                    
  ##  ##    ##                    ##  ##    ##                  
              ##                              ##                
##    ##        ##              ##    ##        ##              
    ##      ##########              ##      ##########          
            ##########                      ##########          
        ##################              ##################      
      ######################          ######################    
      ######################          ######################    
    ##########################      ##########################  
    ################  ########      ################  ########  
      ##############  ######          ##############  ######    
      ############  ########          ############  ########    
        ##################              ##################      
          ##############                  ##############        
              ######                          ######
— 埃尔佩德罗
source
" #"[e>0]*2将工作
— 乔纳森·艾伦
DOH！我怎么想念那个的？？？感谢@乔纳森
— ElPedro
...括号(...)也可以走（RE：根据我之前的评论）。
— 乔纳森·艾伦
您可以通过for y in ...:print"".join(" #"[e>0]*2for e in(([0]*7+map(int,bin(y)[2:]))[-16:]))*z
— Jonathan Allan
@乔纳森再次感谢。这里已经很晚了，所以我将把更改保存到明天，以便我不会完全搞砸。
— ElPedro
3

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>
展开摘要

— 阿塔科
source
3

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几次。

调整

  • 仅使用一个for循环节省了4个字节
  • 通过为每次迭代打印单个char并使用字符串索引而不是三进制来保存字节
  • 通过使用将$j行边界重置为零来节省一个字节%=。这摆脱了括号
  • 通过使用保存了2个字节 $argn
— ros
source
3

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版本，编译器将字符串存储为宽字符数组-运行时每个字符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以下），但是仍然存在。大多数网页都是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位整数，则可以省略Wide Char的wchar_t类型声明。Ideone没有抱怨，所以我认为这是一件好事。

试试吧上ideone

— 黏土驴
source
令人印象深刻。这使用什么编码？
— DJMcMayhem
它是在MinGW GCC上编译的，其中宽字符是uint16。因此，编码为[保留UTF-16 Unicode的16位类型]。但是，我认为因为字符在0xFF（16位）以内，所以扩展了ASCII。+没什么特别的
— claydonkey
抱歉，我对编码了解得更多，并且可能将其存储为UTF-16是错误的。请参考经过全面修改的答案。
— claydonkey
2

Haskell，155个字节

作为具有type的函数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]]
— 尼克·汉森
source
2

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溢出以结束每一行。

嗯，我在打高尔夫球时将printf（）更改为写操作，但是这样就打破了。在此处测试ideone.com/JtHInD
2

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

}
— 马可13
source
1
我知道它已经过了一年，但可以将其高尔夫这样：n->{String s="";for(int x,r=0;r<16*n;s+=(++r%n<1?"\n":""))for(x=16;x-->0;)s+=((new int[]{1536,10496,128,18496,4592,496,2044,4094,4094,8191,8175,4078,4062,2044,1016,224}[r/n])&(1<<x))<1?" ":"##";return s;}（205个字节）除了使用Java 8拉姆达，我已经改变减少更多的字节：的位置x=16（而改while到for）; 2x ==0至<1; 返回s而不是打印它（导入也是字节数btw ..的一部分）；--x>=0到x-->0。不过，答案很好，所以+1！
— 凯文·克鲁伊森
@KevinCruijssen谢谢（考虑将其作为自己的答案发布）。我在codegolf上不是很活跃，因此不确定规则，但是我认为在大多数情况下，只允许计数函数的字节数（并忽略导入）。
— Marco13年
有点像单独发布答案一样，但是我能理解您是否不想编辑一年多以前的答案。:)我将其留在评论中。而且我恐怕进口确实会计入字节数。
— 凯文·克鲁伊森
2

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)

当使用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'

后面的字符串是一个偏移量为的以95为基数的编码字符串32，因此所有字符都落入ASCII范围，并且值得庆幸的是'，不需要转义s。3 u:获取字符串的字符代码，32x-~使每个数字成为e x趋近数并32从中减去；95#.转换为基数为95的数字，然后2#.inv将其转换为二进制数字数组。我1在二进制文件中添加了一个引号，以使其成为实数，因此我将其取下}.。我将阵列定型为16x16表格，16 16$然后使用进行转置|:。（可能的打高尔夫球：稍后进行：转置原义编码的字符串。）在2#宽度方向上复制每个字符。我们只剩下0s和1s 表。' #'{~地图0s到' '和1到'#'。这样，我们就留下了炸弹。

测试用例

   |:@;@#&(<' #'{~2#|:16 16$}.2#.inv 95#.32x-~3 u:'u,:C>%}UwPXHn_C9wF.|U ap<{jH%O9 9wRThGs') 3
        ####                            ####                            ####
  ##  ##    ##                    ##  ##    ##                    ##  ##    ##
              ##                              ##                              ##
##    ##        ##              ##    ##        ##              ##    ##        ##
    ##      ##########              ##      ##########              ##      ##########
            ##########                      ##########                      ##########
        ##################              ##################              ##################
      ######################          ######################          ######################
      ######################          ######################          ######################
    ##########################      ##########################      ##########################
    ################  ########      ################  ########      ################  ########
      ##############  ######          ##############  ######          ##############  ######
      ############  ########          ############  ########          ############  ########
        ##################              ##################              ##################
          ##############                  ##############                  ##############
              ######                          ######                          ######
— 科纳·奥布莱恩
source
2

腊肉，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}

输出：

        ####                            ####                    
  ##  ##    ##                    ##  ##    ##                  
              ##                              ##                
##    ##        ##              ##    ##        ##              
    ##      ##########              ##      ##########          
            ##########                      ##########          
        ##################              ##################      
      ######################          ######################    
      ######################          ######################    
    ##########################      ##########################  
    ################  ########      ################  ########  
      ##############  ######          ##############  ######    
      ############  ########          ############  ########    
        ##################              ##################      
          ##############                  ##############        
              ######                          ######
— 彼得
source
2

Haskell，191181字节

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]]
— 昂斯
source
2

C（Atari TOS 2.06 US），129124117113字节

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不包含炸弹位图！

如果不提供命令行参数，则可能会显示几个高分辨率位图炸弹:-)

— 吊顶猫
source
1

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

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字符已由xs 代替。
十六进制值：0008,0002,0610,1F8A,3FC1,7FC1,7FF2,FFF4,FFF8,EFF0,73F0,7FC0,3FC0,1F80,0600
由于SB将文件保存为UTF-8，因此其中一些计数为2或3个字节。

— 12Me21
source
@Arnauld我不知道很多关于SmileBASIC，但考虑到有一个环FOR K=1TO N带INPUT N，我想它会显示在输入给定的炸弹的数量。但是，我必须说，尽管是方形字体，但我认为字符仍应加倍以与要求保持一致（以避免优于其他答案）。您可以保留当前的版本，以获得更好的解决方案，但我认为您仍然应该添加正确的解决方案。添加后，我将投票支持UTF-8字符的创造性使用！
— HyperNeutrino'2
@AlexL。是的，我的评论是在代码更新之前进行的。
— Arnauld
1

Ruby 2.x（lambda）-157字节

可以进一步打高尔夫球，但我喜欢这个版本：

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

与python版本类似的想法：将十六进制编码的炸弹的字符串分成4个字符的部分，转换为二进制，转换1为#和0。每个字符加倍，然后打印结果数组。

请注意，puts用于打印数组。这样会将数组每个元素打印一行。

— Nerketur Kamachi
source
1

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

输出量

巴邦

— 泰勒·斯科特
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.