소개

아타리 ST는 모토로라 68000 마이크로 프로세서에 의해 구동 초 90의 시대 중반 80 년대에서 오히려 인기 개인용 컴퓨터이었다. 이 시스템에서 포착되지 않은 CPU 예외에 대한 운영 체제의 기본 동작은 다음 그림과 같이 화면에 일련의 폭탄을 표시하는 것입니다.

_{출처 : https://commons.wikimedia.org/wiki/File:Row_of_bombs.png
NB : 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 폭탄을 원래 너비의 두 배로 늘려야합니다. 따라서 ##'ON'픽셀을 사용하고 'OFF'픽셀을 위해 2 개의 공백을 사용하여 16 개의 32 문자 32 행으로 구성됩니다 . 모든 폭탄 타일은 나란히 놓아야합니다. 선행 공백은 금지되어 있습니다. 후행 공간은 실제로 폭탄 타일 (즉, 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 바이트-문자를 두 배로 잊어 버렸습니다 (아무도 눈치 채지 못했습니다!)

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

TryItOnline

어떻게?

원본 이미지의 길이 인코딩으로 데이터를 압축하는 것이 준비되었습니다.

• 새 줄을 무시하고 이미지에서 1s (space) 또는 0s (hash) 의 각 실행 길이를 계산합니다 [4,2,11,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를 수행하므로 공백이 홀수이고 해시도 짝수입니다.

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

그런 다음 이것을 base 10으로 변환 한 다음 05AB1E의 최대 base 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

온라인으로 사용해보십시오.

자바 스크립트 (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로 시작 하므로 )하여 문자로 변환하고 결과 문자를 연결합니다 .

압축을 풀려면 문자 코드를 추출하고 이진 표현을 해시 및 공백 문자열로 바꿔야합니다. 다음과 같이 재귀 함수를 사용하여 수행 할 수 있습니다.

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

f반복적으로 마지막 비트를 취하여 q1이면 두 개의 공백을 선택하고 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 근처에 오지 않습니다.

MS-DOS .COM 파일, 84 바이트

승인. 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-9)

파이썬, 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에서 사용해보십시오!

즉석에서 문자열 목록을 작성하는 대신 색인화되고 2 진으로 변환 된 하드 코딩 된 16 진 문자열이 있습니다. 그런 다음 각 이진수는 ' '또는 로 바뀌어 '#'복제되고 결합됩니다 ... 등

첫 번째 접근법 :

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

/// , 539532 + 아니오 폭탄 바이트

첫 번째 /// 답변은 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

온라인으로 사용해보십시오!

입력 소수점 있어야한다면, 다음 갖는다 555 (마지막 숫자 1, 2, 3 또는 4로 변경 될 수있다) 548 바이트 :

/-/?|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 폭탄의 각 행을 각각 의미
수단 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의 선행 공백은 이진 표현을 채울 필요가 없음)을 바꾼 다음 base-136의 문자열로 바꿈 (가장 짧은 문자열을 생성 함) 넓은 문자없이). 이 단계는 여기 에서 재생할 수 있습니다 .

이 대답은 인코딩을 되돌립니다. 주된 요령은 전치하기 전에 폭탄을 반복하여 효과적으로 폭탄의 각 라인을 한 번에 연결하는 것입니다. 그런 다음 각 줄의 문자를 최종 출력을 위해 줄 바꿈을 삽입하여 두 배로 늘릴 수 있습니다.

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 진 디지트 대체 02 개 공간과 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"

온라인으로 사용해보십시오!

설명

이 코드는 16x16 이진 행렬의 미리 압축 된 버전을 사용합니다. 사전 압축 (프로그램의 일부는 아님)은 두 단계를 사용했습니다.

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"

생성 된 벡터의 실행을 containis 1, 2... 49, 512 개 항목의 총. 이것은 16 × 32 매트릭스로 재 형성됩니다 :

                                            32e!

' #'단일 폭탄을 생성하기 위해 스트링 에 모듈 형 인덱스로 사용됩니다 .

                                                ' #'w)

마지막으로 입력에 의해 주어진 요인에 의한 수평 반복은 원하는 결과를 생성합니다.

                                                      liX"

파이썬 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의 코드가 더 짧아짐을 알았습니다.)

문자열은 공백을 1로 처리하고 해시를 0으로 처리 한 다음 밑줄을 36으로 변환하여 형성됩니다. 그런 다음 프로그램은 다시 이진 및 슬라이스를 16의 길이로 변환합니다 (Python 앞의 '0b'에 대해 2의 오프셋을 사용함) 이진 문자열), 이중 공백 및 이중 해시로 변환하고 결합하여 문자열 n시간을 반복하여 인쇄합니다.

이전 : Python 2, 169166163 바이트

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

내 젤리 답변 의 거의 항구 .

Python 2.7, 144141 바이트

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

폭탄은 공간을 위해 1로 2 진으로 작성되며 선행 1은 2 진 표현을 채울 필요가 없습니다. 폭탄은 ( CJam의 답변 과 매우 비슷하게 ) 옮겨져 기본 36에 저장됩니다.

이 프로그램은 폭탄을 이진으로 해독하고 전치 효과를 효과적으로 따르는 16 단계 씩 비트를 반복합니다 (이는 주어진 줄을 슬라이싱하여 바이트를 절약합니다). 결과 라인이 연결되고 비트가 double 또는 로 대체되어 #단일 문자열로 결합됩니다.

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

온라인으로 사용해보십시오!

명령 행 매개 변수가 제공되지 않으면이 segfault입니다.

배치, 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

숫자 목록에서 16 진수를 보았지만 노력의 가치가있을만큼 충분히 절약하지는 못했습니다. 코드를 다운받을 수 있기를 바랐지만이 접근법으로 가능한 한 멀리 떨어져있는 것 같습니다. 추가로 힌트를 받았습니다.

편집하다

-1 변화시킴으로써 e==1로 e>0. 나는 항상 그 것을 잊습니다.

-2 앞에 이진수 문자열의 길이를 무시하고 7을 앞에두고 마지막 16 개 요소 만 가져 와서 -2입니다. 선행 0이 7 개를 넘지 않으므로 작동

-4 이제 변수 b에 대한 두 번째 참조를 잃어 버렸기 때문에 bin(y)[2:]매직 200 아래에서 가져 오는 맵 함수에서 직접 사용할 수 있습니다 :-)

두 번째 목록에서 슬라이스 할당을 사용하여 -8 오늘 저녁에 새로운 것을 배웠습니다.

@Jonathan 덕분에 -3

c=d=([0]*7+map(int,bin(y)[2:]))[-16:]대신 에 사용하여 -2c=d;

@Jonathan 덕분에 다시 -2

@Linus 덕분에 -24

산출

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

RProgN , 210 193 바이트

0 = ''1 = '##'을 1 = ''0 = ''으로 전환하여 일부 바이트를 절약했습니다. 즉, 여분의 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-loop 만 사용하여 4 바이트 절약
• 각 반복마다 단일 문자를 인쇄하고 삼항 대신 문자열 색인을 사용하여 바이트를 절약했습니다.
• 로 $j줄 경계에서 0으로 재설정하여 바이트를 저장했습니다 %=. 이것은 괄호를 제거합니다
• 를 사용하여 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

설명

먼저 폭탄의 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 버전 컴파일러는 런타임에 각 문자에 대해 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은 불평하지 않으므로 갈 것이 좋다고 생각합니다.

이데온 에서 사용해보십시오

하스켈, 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]]

(우리가 돌아 선호하는 경우 또는 6 바로 5 바이트 비용을 부담 IO에 인쇄 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를 오버플로하여 각 행을 종료합니다.

자바, 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)

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-~각 숫자를 확장 된 x숫자로 만들고 빼 냅니다 32. 95#.기수 -95 숫자로 2#.inv변환하고 이진수 배열로 변환합니다. 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
        ####                            ####                            ####
  ##  ##    ##                    ##  ##    ##                    ##  ##    ##
              ##                              ##                              ##
##    ##        ##              ##    ##        ##              ##    ##        ##
    ##      ##########              ##      ##########              ##      ##########
            ##########                      ##########                      ##########
        ##################              ##################              ##################
      ######################          ######################          ######################
      ######################          ######################          ######################
    ##########################      ##########################      ##########################
    ################  ########      ################  ########      ################  ########
      ##############  ######          ##############  ######          ##############  ######
      ############  ########          ############  ########          ############  ########
        ##################              ##################              ##################
          ##############                  ##############                  ##############
              ######                          ######                          ######

베이컨 , 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}

출력 :

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

하스켈, 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]]

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. 일부 에뮬레이터 롬에는 폭탄 비트 맵이 포함되어 있지 않습니다!

명령 행 인수를 제공하지 않으면 여러 고해상도 비트 맵 폭탄이 표시 될 수 있습니다. :-)

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.
16 진 값 : 0008,0002,0610,1F8A,3FC1,7FC1,7FF2,FFF4,FFF8,EFF0,73F0,7FC0,3FC0,1F80,0600
SB는 파일을 UTF-8로 저장하므로이 중 일부는 2 또는 3 바이트로 계산됩니다.

루비 2.x (람다)-157 바이트

아마도 더 골프를 칠 수 있지만이 버전을 좋아합니다.

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

파이썬 버전과 비슷한 생각 (들) : 이진에 4 자, 변환의 섹션으로 진수 인코딩 폭탄의 문자열을 깰 번역 1에 #와 0에 , 모든 문자를 두 번, 결과 배열을 인쇄 할 수 있습니다.

puts는 배열을 인쇄하는 데 사용됩니다. 그러면 요소 당 한 줄씩 배열이 인쇄됩니다.

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

산출