Вступ

Atari ST був досить популярним персональним комп'ютером з середини 80 - х до початку 90 -х років епохи, харчування від Motorola 68000 мікропроцесор. На цій машині поведінка операційної системи за умовчанням для винятків винятків із процесора полягала в тому, щоб відображати ряд бомб на екрані, як показано на наступному малюнку:

_{Джерело: https://commons.wikimedia.org/wiki/File:Row_of_bombs.png
Примітка: Залежно від версії ОС, графіки бомб можуть дещо відрізнятися. Але візьмемо це як довідкове.}

Кількість бомб залежить від вектора виключення, найпоширенішими з них є:

• ($ 008) Помилка автобуса: 2 бомби
• Помилка адреси: 3 бомби
• ($ 010) Незаконна інструкція: 4 бомби

Мета

Ваша мета - написати програму або функцію, яка друкує або виводить ASCII мистецтво таких бомб Atari ST.

Вхідні дані

Ціле число, що представляє кількість бомб, які потрібно відобразити. Ваш код повинен підтримувати найпоширеніші значення: 2, 3 і 4. Підтримка меншої та / або більшої кількості бомб - це добре, але це не потрібно і не підлягає бонусу.

Вихід

Оригінальна бомба складається з плитки розміром 16x16 пікселів, представленої тут як у ASCII, так і у двійковій формі:

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

У цьому виклику кожну бомбу ASCII необхідно розтягнути до вдвічі більше її вихідної ширини для кращого відтворення. Таким чином, він буде складатися з 16 рядків з 32 символів, використовуючи ##для пікселів 'ON' та двох пробілів для пікселів '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можуть бути використані так само добре.)

Правила

Це код-гольф, тому найкоротша відповідь у байтах виграє. Стандартні лазівки заборонені.

Желе , 43 44 байт

+1 байт - забув подвоїти символів (не те, щоб хтось помітив!)

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

TryItOnline

Як?

Підготовка полягала в стисканні даних у вигляді кодування довжини пробігу вихідного зображення:

• Порахуйте довжину кожного пробігу 1s (пробіл) або 0s (хеш) на зображенні, ігноруючи нові рядки - виходить список [4,2,11,1,1,...]:;
• Віднімайте по одному від кожного числа - це дає діапазон [0,15];
• Трактуйте це як число 16-базового (перерахуйте значення v, з індексом iу зворотному і підсумовуйте 16**i*v= 19468823747267181273462257760938030726282593096816512166437);
• Перетворити це в базу-250 [5,119,249,42,...]:;
• Позначте на кодовій сторінці Jelly у вигляді індексів: ¥vẏ)X;ndĊɓ¡ẹ3ċi}Ịɲ¡P

Тепер код оцінює це число, відображає 1s і 0s на пробіл та хеш-символи *, подвоює кожен, розбивається на рядки і повторює кожну відповідну кількість разів.
* насправді реалізація виконується по модулю 2 для збереження байтів, тому пробіли є непарними, а хеші - парними:

“¥vẏ)X;ndĊɓ¡ẹ3ċi}Ịɲ¡P"¦ḊƥṾ’b⁴‘ĖŒṙị⁾ #Ḥs⁴ẋ€³Y - Main link: n
“¥vẏ)X;ndĊɓ¡ẹ3ċi}Ịɲ¡P"¦ḊƥṾ’                  - base 250 number, as above
                           b⁴                - convert to base 16 (the run length - 1 list)
                             ‘               - increment (vectorises) (the run length list)
                              Ė              - enumerate (pairs each with 1,2,3...)
                               Œṙ            - run length decode
                                              ([1,1,1,1,2,2,3,3,3,3,3,3,3,3,3,3,3,4,5,...])
                                  ⁾ #        - string " #"
                                 ị           - index into (1 based and modular)
                                              (makes a bomb without line feeds)
                                     Ḥ       - double (each char becomes a list of 2 chars)
                                      s⁴     - split into slices of length 16
                                        ẋ€³  - repeat each input, n, times
                                           Y - join with line feeds

05AB1E , 57 55 53 50 байт

Використовує кодування CP-1252 .

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

Спробуйте в Інтернеті!

Пояснення

Оскільки вихідне зображення складається лише з 2 символів, ми можемо представити його як двійкове число.
Ми можемо ігнорувати нові рядки, оскільки кожен рядок має однакову довжину.
Ми можемо ігнорувати останній знак кожного рядка, оскільки він однаковий для всіх рядків.
Ми використовуємо тонше зображення, оскільки воно займає менше місця, і ми можемо легко дублювати кожен символ пізніше.

Використовуючи 1 для представлення простору і 0 для представлення #, ми отримуємо двійкове число:

111100111111111101011011111111111111101111111011011110111111110111000001111111111000001111111100000000011111000000000001111000000000001110000000000000110000000010000111000000010001111000000100001111100000000011111110000000111111111100011111

Потім ми перетворюємо це в базу-10, а потім стискаємо його до бази 214, максимальна база в 05AB1E. Результатом цього є:

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

М'ясо програми складається з наступного:

<base encoded string>
  b                     # convert to binary
   15ô                  # slice into pieces of 15
      v                 # for each slice  
       1J               # append a 1       
         €D             # duplicate each character
           „#           # push the string "# "
             è          # use the list of binary digits to index into the string
              ¹×        # repeat string input number of times
                ,       # and print with newline

Pyth, 57 56 54 53 51 50 байт

Код містить недруковані символи, тому ось зворотний 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

Спробуйте в Інтернеті.

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 та об'єднує отримані символи .

Щоб розпакувати його, нам потрібно витягнути charcode і перетворити його бінарне подання на рядок хешів і пробілів. Це можна зробити за допомогою рекурсивної функції, наприклад:

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

fкілька разів займає останній біт q, вибираючи два пробіли, якщо це 1 або два хеші, якщо це 0, то поєднує це з результатом запуску fв іншій частині q. Це запускається x.charCodeAt(), перетворюючи char-код у правильний рядок пробілів і хешів.

(Тут раніше було набагато більше драматизму, але техніка 4-байт-економії все це стерла.)

Після цього ми можемо просто повторити рядок nразів і додати новий рядок. Це найкоротший метод декомпресії, який я знайшов, але сміливо пропоную будь-які, можливо, більш короткі методи.

Інші спроби стиснення рядка:

n=>[48,74,128,265,1988,1984,8176,16376,16376,32764,31740,15352,15864,8176,4064,896].map(x=>(f=q=>q?(q&1?"  ":"##")+f(q>>1):"")(65535-x).repeat(n)).join`
`
n=>"1c,22,3k,7d,1j8,1j4,6b4,cmw,cmw,pa4,oho,bug,c8o,6b4,34w,ow".split`,`.map(x=>(f=q=>q?(q&1?"  ":"##")+f(q>>1):"")(65535-parseInt(x,36)).repeat(n)).join`
`
n=>"30,4a,80,109,7c4,7c0,1ff0,3ff8,3ff8,7ffc,7bfc,3bf8,3df8,1ff0,fe0,380".split`,`.map(x=>(f=q=>q?(q&1?"  ":"##")+f(q>>1):"")('0x'+x^65535)).repeat(n)).join`
`

Перший з них - 153 байти, тому жоден з них не надходить близько 136 ...

Файл MS-DOS .COM, 84 байти

ГАРАЗД. Просто заради задоволення, тому що я не можу обіграти 50 байт ...

Пробували як у DOSbox, так і під MS-DOS 6.22 у віртуальній машині.

У програмі DOSbox програма працює добре, проте в реальному MS-DOS вихід не відображатиметься належним чином, оскільки DOS вимагає CR-LF замість LF в кінці рядка.

(Однак вихід правильний.)

Варіант на 88 байт використовуватиме CR-LF в кінці рядка.

Ось файл:

0000  be 32 01 fc ad 89 c3 8a  36 82 00 80 ee 30 b9 10
0010  00 d1 c3 18 d2 80 ca 20  80 e2 23 b4 02 cd 21 cd
0020  21 e2 ee fe ce 75 e7 b2  0a cd 21 ad 85 c0 75 d5
0030  cd 20 00 0c 00 52 00 01  80 90 e0 23 e0 03 f8 0f
0040  fc 1f fc 1f fe 3f de 3f  dc 1f bc 1f f8 0f f0 07
0050  c0 01 00 00

Код асемблера (у синтаксисі AT&T) виглядає приблизно так:

start:
      # Read data from "image:"
    mov $image,%si
    cld
      # Read the first 16 bytes
    lodsw
nextLine:
      # Use bx as shift register
    mov %ax, %bx
      # Read the number of bombs
    mov 0x82,%dh
    sub $'0',%dh
nextBombInThisLine:
      # Number of characters
    mov $16, %cx
nextCharacter:
      # Rotate the data# get the next bit to CY
    rol $1, %bx
      # This results in 0x23 ('#') if CY is set, to 0x20 (' ') otherwise
    sbb %dl, %dl
    or $0x20, %dl
    and $0x23, %dl
      # Print result character twice
    mov $2, %ah
    int $0x21
    int $0x21
      # more Characters in this line?
    loop nextCharacter
      # More bombs to draw?
    dec %dh
    jnz nextBombInThisLine
      # Print a newline
#        mov $13, %dl # <- Additional 4 bytes needed for "\r\n"
#        int $0x21    #    at the end of the line!
    mov $10, %dl
    int $0x21
      # Read the next 16 bytes# 0x0000 means: EOF
    lodsw
    test %ax,%ax
    jnz nextLine
      # End of program
    int $0x20
image:
    # Here 34 bytes follow:
    # 16 16-bit-words "bitmap" for the bombs followed
    # by 0x0000 indicating the end of the bitmap

--- Редагувати ---

Я забув згадати: програму потрібно запустити із наступного командного рядка:

Назва файлу COM + рівно один пробіл + Кількість бомб (1-9)

Пітон, 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!

Замість того, щоб створювати список рядків на ходу, існує жорстко закодований шістнадцятковий рядок, який індексується та перетворюється у двійковий; то кожна двійкова цифра перетворюється на або, ' 'або '#'дублюється і з’єднується разом ... і т.д.

Перший підхід:

s='  ';b='##';f=lambda n:'\n'.join(n*l.ljust(32)for l in[s*4+b*2,(s+b)*2+s*2+b,s*7+b,b+s*2+b+s*4+b,s*2+b+s*3+b*5,s*6+b*5,s*4+b*9,s*3+b*11,s*3+b*11,s*2+b*13,s*2+b*8+s+b*4,s*3+b*7+s+b*3,s*3+b*6+s+b*4,s*4+b*9,s*5+b*7,s*7+b*3])

Спробуйте на repl.it!

Він містить жорстко закодований список рядків кожного рядка (не включаючи пробіли), створені шляхом дублювання ' 'або '##'декількох разів. Для кожного з цих рядків вони прокладені пробілами довжиною до 32 символів, подвоєні nрази, а потім з'єднані з новими рядками.

C, 250 240 208 188 байт

d[]={3072,20992,256,36992,9184,992,4088,8188,8188,16382,16350,8156,8124,4088,2032,448,0},m,c,*i=d;f(k){for(;*i;i++,puts(""))for(c=k;c--;)for(m=32768;m;write(1,&"##  "[m&*i?0:2],2),m>>=1);}

Перейдіть до використання функції.

m,d[]={3072,20992,256,36992,9184,992,4088,8188,8188,16382,16350,8156,8124,4088,2032,448,0},*i=d;main(c,v)char**v;{for(;*i;puts(""),i++)for(c=atoi(v[1]);c--;)for(m=32768;m;write(1,&"##  "[m&*i?0:2],2),m>>=1);}

Тест, як це. main(c,v)char**v; { f(atoi(v[1])); }

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

/// , 539 532 + ні. бомб бомб

Перша /// відповідь, відображаючи 4 бомби. Кінець чотирьох 1 можна замінити будь-яким одинарним поданням кількості бомб, які ви хочете роздрукувати (11 для 2, 111 для 3)

/-/?|X//y/\/X//xy|//|/\/\///+/%@!|$/bcd|%/efg|@/hij|!/klm|?/nop|b/Bxc/Cxd/Dxe/Exf/Fxg/Gxh/Hxi/Ixj/Jxk/Kxl/Lxm/Mxn/Nxo/Oxp/Pxq/ss|r/tt|s/SS|t/TT|S/  |T/##|1/AX$+-$+?AXyAX$+-cd+?by$+-d+?cycd+-+?dyd+-fg@!?ey+-g@!?fyfg@!-@!?gyg@!-ij!?hy@!-j!?iyij!-!?jyj!-lm?ky!-m?lylm-?mym-opny-poyop|AXA/AA|bB/BB|cC/CC|dD/DD|eE/EE|fF/FF|gG/GG|hH/HH|iI/II|jJ/JJ|kK/KK|lL/LL|mM/MM|nN/NN|oO/OO|pP/PP|A/qtqqs|B/STSTsTqqS|C/qsSTqq|D/TsTqTqsS|E/sTsSrTqS|F/qsrTqS|G/qrrTsS|H/sSrrtTs|I/sSrrtTs|J/srrrTS|K/srrSrS|L/sSrtTStTs|M/sSrtSrs|N/qrrTsS|O/qSrtTq|P/qsStTqs|X/
/1111

Спробуйте в Інтернеті!

Якщо вхід повинен бути десятковим, наступне містить 555 548 байт (де останню цифру можна змінити на 1, 2, 3 або 4):

/-/?|X//y/\/X//xy|//|/\/\///4/13|3/12|2/11|^/tT|&/rr|*/sS|+/%@!|$/bcd|%/efg|@/hij|!/klm|?/nop|b/Bxc/Cxd/Dxe/Exf/Fxg/Gxh/Hxi/Ixj/Jxk/Kxl/Lxm/Mxn/Nxo/Oxp/Pxq/ss|r/tt|s/SS|t/TT|S/  |T/##|1/AX$+-$+?AXyAX$+-cd+?by$+-d+?cycd+-+?dyd+-fg@!?ey+-g@!?fyfg@!-@!?gyg@!-ij!?hy@!-j!?iyij!-!?jyj!-lm?ky!-m?lylm-?mym-opny-poyop|AXA/AA|bB/BB|cC/CC|dD/DD|eE/EE|fF/FF|gG/GG|hH/HH|iI/II|jJ/JJ|kK/KK|lL/LL|mM/MM|nN/NN|oO/OO|pP/PP|A/qtqqs|B/STSTsTqqS|C/q*Tqq|D/TsTqTq*|E/sT*rTqS|F/qsrTqS|G/q&T*|H/*&^s|I/*&^s|J/s&rTS|K/s&SrS|L/*r^S^s|M/*rtSrs|N/q&T*|O/qSr^q|P/q*^qs|X/
/4

Спробуйте в Інтернеті!

Найважливішими частинами коду є:
| означає //
ABCDEFGHIJKLMNOP означає кожну лінію бомби відповідно
S означає 2 пробіли
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, 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. Попереднє стиснення (не є частиною програми) використовувало два етапи:

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 записів). Але замість цього використовувати коротше вектор [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.)

Рядок був утворений обробкою пробілів як 1s і хешами як 0s, а потім перетворенням на базу 36. Потім програма перетворює назад у двійкові та фрагменти довжиною 16 (зі зміщенням 2 для '0b' на передній частині Python's двійковий рядок), перетворює у подвійні пробіли та подвійні хеші, з'єднує їх, повторює 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

Майже портрет моєї відповіді на желе .

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, ефективно після перенесення (що економить байти під час нарізання заданої лінії). Отриманий рядок є з'єднаним, біти замінюються подвоєними або #і з'єднуються в сингє-рядок.

C (gcc) , 216 204 183 165 134 байт

b(n,i){for(n*=16,i=--n*16;i--;i%n||puts(""))printf(L"àϸ\x7fc\xfde\xfee`\x1fff\xffe\xffe\x7fcǰᇰ䡀\x80⤀\x600"[i/n]&1<<i%n%16?"##":"  ");}

Спробуйте в Інтернеті!

Написано як окрема програма ( 201 183 151 байт)

i=16;main(j,l)char**l;{for(;i--;puts(""))for(j=*l[1]*16-769;j--;printf(L"àϸ\x7fc\xfde\xfee`\x1fff\xffe\xffe\x7fcǰᇰ䡀\x80⤀\x600"[i]&1<<j%16?"##":"  "));}

Спробуйте в Інтернеті!

Цей сегментарний параметр, якщо параметр командного рядка не надається.

Пакетна, 415 байт

@echo off
set h=#####
set s=
for %%a in ("    ##%s%%s%" " # #  #%s%    " "%s%  #%s%   " "#  #    #%s%  " "  #%h%%s%" "%s% %h%%s%" "    %h%####   " "   %h%%h%#  " "   %h%%h%#  " "  %h%%h%### " "  %h%### #### " "   %h%## ###  " "   %h%# ####  " "    %h%####   " "%s%%h%##    " "%s%  ###%s% ")do call:l %1 %%a
exit/b
:l
set r=
for /l %%i in (1,1,%1) do call set r=%%r%%%~2
set r=%r: =  %
echo %r:#=##%

Примітка: рядок set s=закінчується в 5 проміжках. Приймає рахунок як параметр командного рядка. Просто проведіть петлі через кожен рядок бомби (стиснуте дуже незначно, видаливши прогони з 5 однакових символів), потім повторіть бомбу стільки разів, скільки потрібно, перш ніж остаточно дублювати кожен символ.

Python 2, 206 205 203 199 191 188 186 184 160 байт

z=input()
for y in 3072,20992,256,36992,9184,992,4088,8188,8188,16382,16350,8156,8124,4088,2032,448:print"".join(" #"[e>0]*2for e in map(int,bin(y+8**6)[5:]))*z

Подивився на Hex за списком номерів, але, схоже, це не економило достатньо, щоб зробити це вартим зусиль. Сподівався, що зможу пограти в гольф, але, здається, я досяг цього, наскільки я можу з цим підходом. Будь-які додаткові підказки вдячно отримані.

EDIT

-1, змінивши e==1на e>0. Я завжди забуваю це.

-2, ігноруючи довжину двійкового рядка, попередньо додавши 7 0 і взявши лише останні 16 елементів. Працює так, як ніколи не існує більше 7 ведучих 0.

-4, тому що тепер, коли я втратив друге посилання на змінну b, я можу використовувати bin(y)[2:]безпосередньо у функції карти, приймаючи її нижче магії 200 :-)

-8, використовуючи призначення зрізів у другому списку. Дізнався чогось нового цього вечора.

-3, завдяки @Jonathan

-2, використовуючи c=d=([0]*7+map(int,bin(y)[2:]))[-16:]замість того, щоб матиc=d;

-2 знову завдяки @Jonathan

-24, завдяки @Linus

Вихід

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

RProgN , 210 193 байт

Збережено кілька байтів, переключивши 0 = '' 1 = '##' на 1 = '' 0 = '', це означає, що мені не потрібно додавати зайві нулі назад. Також це означає, що тепер рядок B64, який раніше говорив "МАФІЯ", немає, це сумно.

'n' = => 64 -B 2 B ] 1 16 sub n rep \ 17 32 sub n rep '
' \ . . '1' '  ' replace '0' '##' replace } a'' = D4D/4/'' a DgQ/AH'' a DAIeAj'' a DgA8AB'' a DwB+AD'' a DcH/wf'' a D+/29/'' a Dz/63/'' a

Пояснення

'n' =                   # Associate the input with "n"
=>                      # Push a new function to the stack.
    64 -B               # Take the value from the top of the stack, convert it to an integer from Base64
    2 B                 # Take the value from the top of the stack, convert it from an integer to binary
    ]                   # Duplicate the top of the stack.
    1 16 sub            # Push the substring from the top of the stack between 1 and 16, 1 indexed.
    n                   # Push the input.
    rep                 # Repeat, this gives us 'n' bombs, essentially.
    \                   # Flip the values such that REPEATEDBOMB_ROW TEXT
    17 32 sub           # Push the substring between 17 and 32.
    n                   # Push the input
    rep                 # Repeat
    '                   # Push a new line
'                       # RProgN doesn't actually have escapes, so the raw newline is represented as a newline between qoutes.
    \ . .               # Flip the values so we have LINE1 NEWLINE LINE2, then concatenate them all into one string.
    '1' '  ' replace    # Replace all the 1's in the binary string with two spaces.
    '0' '##' replace    # Replace all the 1's with two '#'s
} a'' =                 # Associate the function with 'a'
D4D/4/'' a              # Bottom two lines,
DgQ/AH'' a              # Next two up,
DAIeAj'' a              # Etc...
DgA8AB'' a              # Once This is done, the memory stack is implicitly printed from top to bottom.
DwB+AD'' a              # As such, the bomb is upside down.
DcH/wf'' a              # Each of these numbers represents two lines, which is why we do the substringing to split it.
D+/29/'' a              # This works out saving a few bytes.
Dz/63/'' a              # Implicitly printed output. Yay.

Досить довго: Розгортання, друк і таке стиснене рядок - це 105 байт. Це може бути трохи більше гольфу, але принаймні це працює.

Введення неявно на стеці, стек неявно друкується.

Вихід

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

Спробуй це!

<style>
  #frame{
    width:60em;
    height:60em;
    border:none;
  }
</style>
<iframe id='frame' src="https://tehflamintaco.github.io/Reverse-Programmer-Notation/RProgN.html?rpn=%27n%27%20%3D%20%3D%3E%2064%20-B%202%20B%20%5D%201%2016%20sub%20n%20rep%20%5C%2017%2032%20sub%20n%20rep%20%27%0A%27%20%5C%20.%20.%20%271%27%20%27%20%20%27%20replace%20%270%27%20%27%23%23%27%20replace%20%7D%20a%27%27%20%3D%20D4D%2F4%2F%27%27%20a%20DgQ%2FAH%27%27%20a%20DAIeAj%27%27%20a%20DgA8AB%27%27%20a%20DwB%2BAD%27%27%20a%20DcH%2Fwf%27%27%20a%20D%2B%2F29%2F%27%27%20a%20Dz%2F63%2F%27%27%20a&input=1">Sorry, You need to support IFrame. Why don't you..?</iframe>

PHP, 144 140 139 138 136 байт

Примітка: використовується кодування Windows-1252

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

Бігайте так:

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

Або використовуючи кодування IBM-850 (135 байт і кращий результат):

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

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

Пояснення

Це не робить ніяких двійкових матеріалів і не вимагає зовнішнього файлу.

Кожне 16-бітове число обернено, потім кодується як базове число 36, 0при необхідності додається ведучим , тому кожні 16 біт призводять до 3-х байт. Об'єднання цих результатів у 01c02203k07d1j81j46b4cmwcmwpa4ohobugc8o6b434w0ow. Код обертає процес, тому бомби друкуються правильно Nразів.

Налаштування

• Збережено 4 байти, використовуючи лише один цикл for
• Збережено байт, надрукувавши одну таблицю для кожної ітерації та використовуючи рядковий індекс, а не потрійний
• Збережено байт шляхом скидання $jдо нуля на межі рядка з %=. Це позбавляється дужок
• Збережено 2 байти за допомогою $argn

GCC C 129 байт

ISO8859 / ASCII

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

В одному рядку:

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

Виконати з:

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

Компілюйте джерело як ISO8859-x (ASCII).

Примітка ÿÿþÿÿÿþÿÿÿþÿÜÜðààАА! À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 компілятор зберігає рядок у вигляді широкого масиву Char - 2 або 4 байти для кожного символу під час виконання, але це є академічним). Тоді як символи UTF-8 зберігатимуться як 2-4 байти, ці значення знаходяться в межах ISO-8859-1 (ASCII) і, таким чином, вимагають лише 1 байт. Також безпечно зберігати його як ISO-8859-x (немає значень 0x8_ або 0x9_). Тому текст використовує 32 байти в ISO-8859, а звичайний - 135 байт.

(NB широкі символи зберігаються як 16-бітове ціле число у Windows та 32-бітне в Linux, але це знову-таки не має значення для заданої задачі)

Caveat: Не всі символи відображаються (контрольні символи нижче 0x20). Однак вони все ще присутні. Більшість веб-сторінок - utf-8 / 8859/1253 ( https://w3techs.com/technologies/overview/character_encoding/all ), тому я вважаю, що це законно (переміщення всіх значень нижче 0x20 на друкований ASCII має це виправити).

UTF-8

Ось версія, ближче до початкової публікації з кодованим джерелом UTF-8. На це витрачається 173 байти. Сам рядок становить 50 байт джерела. Процедура також довша, оскільки байти ASCII тепер зберігаються з підкладкою 0 для 16-бітових / 32-бітових широких таблиць і повинні бути зміщені замість кастингу на uint16_t, як вище. Я продовжував це, оскільки це можна підтвердити за допомогою ideone, який використовує кодування UTF-8.

*w=L"óÿ­ÿþÿoÜüðààÀÀ!ÀCàCðøþ?";
f(r,i,j,m){
    for(i;i<32;i+=2,puts(""))
        for(j=r;j--;)
            for(m=65536;m>1;(m\=2,printf(((w[i]<<8)+w[i+1]&m)?"  ":"##")));}

Виконати з:

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

Якщо ви можете встановити неявне значення на 16-бітове ціле число у своєму компіляторі, ви можете опустити оголошення wchar_t типу Wide Char. Ideone не скаржиться, тому я вважаю, що добре піти.

Спробуйте це на ideone

Haskell, 155 байт

Як функція з типом Int -> String:

b z=concat$do y<-[0..15];"\n":[if odd$div 0x3800FE01FF03DF83BF87BFC7FFC3FF83FF81FF007C007C401090080004A0030(2^(16*y+x))then"##"else"  "|x<-[1..z]>>[0..15]]

Друк на IO безпосередньо коштуватиме 5 байт (або 6, якщо ми віддаємо перевагу поверненню, IO ()а не IO [()]):

b z=mapM putStr$do y<-[0..15];"\n":[if odd$div 0x3800FE01FF03DF83BF87BFC7FFC3FF83FF81FF007C007C401090080004A0030(2^(16*y+x))then"##"else"  "|x<-[1..z]>>[0..15]]

C, 175 байт

 x[]={48,74,128,265,1988,1984,8176,16376,16376,32764,31740,15352,15864,8176,4064,896};f(z,p){while(z++<16){p=1;while(p<<=1){printf("%s",p&(x[z]<<16|x[z])?"##":" ");}puts("");}}

з'єднує кожен х у себе і робить p переповненням для закінчення кожного рядка.

Java, 228 байт

import static java.lang.System.out;

public class Bombs
{
    public static void main(String[] args)
    {
        new Bombs().d(2);
        new Bombs().d(3);
        new Bombs().d(4);
    }

    void d(int n){String s="";for(int x=16,r=0;r<16*n;x=16,s+=(++r%n==0?"\n":""))while(--x>=0)s+=((new int[]{1536,10496,128,18496,4592,496,2044,4094,4094,8191,8175,4078,4062,2044,1016,224}[r/n])&(1<<x))==0?"  ":"##";out.println(s);}

}

J, 89 байт

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

Кодує рядок як базове число 95, збільшуючи кожну цифру на 32, потім представляє його рядком ascii.

Пояснення

Складено з двох основних частин. Існує побудова бомби і власне повторення. Давайте на даний момент позначимо бомбу як b. Потім код виглядає так:

|:@;@#&(b)

Коли дзвонить із введенням k, це еквівалентно:

|: ; (k#b)

bє бомбовою коробкою, тому k#bробить kповтори b, ;розгладжує її вертикально і |:переміщує результат. (Бомба bсама по собі побудована транспонованою.)

Тепер ось бомба:

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

Наступний рядок - це кодована рядок базової-95 із зміщенням 32, так що всі символи потрапляють у діапазон ASCII, і, на щастя, немає таких, які не 'потребують уникнення. 3 u:отримує char-коди рядка, 32x-~робить кожне число e- xтендованим числом і віднімає 32з нього; 95#.перетворює в число базового-95, а 2#.invперетворює його на двійковий розрядний масив. Я додав ведучий 1до двійкового, щоб зробити його суцільним числом, тому я знімаю його }.. Я формую масив у таблицю 16х16, а 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
        ####                            ####                            ####
  ##  ##    ##                    ##  ##    ##                    ##  ##    ##
              ##                              ##                              ##
##    ##        ##              ##    ##        ##              ##    ##        ##
    ##      ##########              ##      ##########              ##      ##########
            ##########                      ##########                      ##########
        ##################              ##################              ##################
      ######################          ######################          ######################
      ######################          ######################          ######################
    ##########################      ##########################      ##########################
    ################  ########      ################  ########      ################  ########
      ##############  ######          ##############  ######          ##############  ######
      ############  ########          ############  ########          ############  ########
        ##################              ##################              ##################
          ##############                  ##############                  ##############
              ######                          ######                          ######

BaCon , 229 227 195 байт

Вклад у БАЗИК заради ностальгії. Змінна 'a' визначає кількість бомб.

a=2:FOR x=0 TO 15:FOR y=1 TO a:FOR i=15 DOWNTO 0:?IIF$(v[x]&INT(POW(2,i)),"##","  ");:NEXT:NEXT:?:NEXT:LOCAL v[]={3072,20992,256,36992,9184,992,4088,8188,8188,16382,16350,8156,8124,4088,2032,448}

Вихід :

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

Haskell, 191 181 байт

f n=h n:f(div n 2)
h n|odd n=' '
h _='#'
g b=mapM_ putStrLn[[f 0xfc7ff01fe00fc207c40784038003c007c007e00ff83ff83bfef6ff7fffb5ffcf!!(x`mod`32`div`2+y*16)|x<-[0..32*b-1]]|y<-[0..15]]

C (Atari TOS 2,06 США), 129 124 117 113 байт

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

Для цього використовується растрова карти бомби з TOS ROM, яка трохи відрізняється від тієї, про яку йдеться. Для інших версій TOS вам доведеться скорегувати адресу, на яку вказано *a. Зауважте, що деякі емуляторні диски не включають растрові карти бомби!

Якщо ви не наводите аргумент командного рядка, може відображатися кілька бомтованих бомб високої роздільної здатності :-)

C ++ 11, 252 байти

#include <iostream>
using namespace std;string d("01c02203k07d1j81j46b4cmwcmwpa4ohobugc8o6b434w0ow");int main(){for(int i=0;i!=45;i+=3){int z=stoi(d.substr(i,3),NULL,36);for(unsigned long p=1;p!=1<<31;p<<=1){cout<<(((z<<16|z)&p)?"##":"  ");}puts("");}}

SmileBASIC, 127 байт

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

(Скріншот версії без подвоєних символів)
SB має квадратний шрифт, тому подвоєння символів виглядає погано (і не вміщується на екрані)
Не символи ASCII були замінені символами xs.
Шістнадцяткові значення: 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}}

Аналогічна ідея, як і версії python: розбийте рядок шістнадцяткових кодованих бомб на розділи по 4 символи, перетворіть у двійкові, перекладіть 1на #та 0до , подвійно кожен символ та надрукуйте отриманий масив.

Зверніть увагу, що put використовується для друку масиву. Це виведе друк масиву по одному рядку на елемент.

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

Вихід