Давайте нарисуем несколько бомб Atari ST!

46

Введение

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

ряд бомб

Источник: https://commons.wikimedia.org/wiki/File:Row_of_bombs.png
NB. В зависимости от версии ОС, изображение бомбы может немного отличаться. Но давайте возьмем это как ссылку.

Количество бомб зависит от вектора исключения, наиболее распространенными из которых являются:

  • ($ 008) Ошибка автобуса: 2 бомбы
  • ($ 00c) Ошибка адреса: 3 бомбы
  • ($ 010) Незаконная инструкция: 4 бомбы

Цель

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

вход

Целое число, представляющее количество бомб для отображения. Ваш код должен поддерживать наиболее распространенные значения: 2, 3 и 4. Поддержка меньшего количества и / или большего количества бомб - это хорошо, но это не требуется и не подлежит бонусу.

Выход

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

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

В этом испытании каждая бомба ASCII должна быть увеличена вдвое по сравнению с первоначальной шириной для лучшего рендеринга. Следовательно, он будет состоять из 16 строк по 32 символа с использованием ##пикселей «ON» и двух пробелов для пикселей «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
источник
Я заметил, что вы исключили формы, не относящиеся к ASCII-искусству, поэтому функция машинного кода Atari ST, которая дает сбой при правильном количестве бомб, не учитывается. (Бомба не в шрифте, но у Atari ST есть глифы забавных / пасхальных яиц в собственном наборе символов, включая символы 28–31, которые представляют собой 4 части, которые формируют образ JR «Bob» Доббса из сатирической Церкви SubGenius . Я помню, как писал программу, которая рассылала спам по этим 4 символам в случайных местах экрана, как очень раннее упражнение в использовании системных вызовов для рисования текста :)
— Питер Кордес
1
@PeterCordes - Это верно, это должен быть ASCII. Тем не менее, вам будет разрешено читать графику бомб с ST ROM, поскольку нет правил, которые мешают вам делать это. (Просто упомяните версию TOS, над которой он должен работать.)
— Арно
1
Ого, это возвращает воспоминания. Моим первым компьютером был Atari ST. Я помню эти бомбы со страхом.
— Род
В сторону: «Количество бомб зависит от вектора исключения» - что скажете ?! Любая причина, почему они не могли вывести фактический код / ​​ошибку? (У меня никогда не было ST, я из лагеря в Амиге ... «Медитация гуру» и все такое.)
— MrWhite

Ответы:

20

Желе , 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,...]:;
  • Карта в кодовую страницу желе в виде индексов: ¥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
— Джонатан Аллан
источник
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, а затем сжимаем в базу 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
— Emigna
источник
12

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

Код содержит непечатаемые символы, так что вот обратимый xxdhexdump.

00000000: 6a2a 4c51 6331 3673 2e65 2a79 6240 2220  j*LQc16s.e*yb@"
00000010: 2322 6b6a 4322 4c49 c142 3c60 0cca 9437  #"kjC"LI.B<`...7
00000020: b383 76bb c246 c86d 4c04 99bd 3614 7022  ..v..F.mL...6.p"
00000030: 3137                                     17

Попробуйте онлайн.

— PurkkaKoodari
источник
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 ), затем превращает ее в символ и объединяет полученные символы ,

Чтобы распаковать его, нам нужно извлечь код и превратить его двоичное представление в строку хешей и пробелов. Это можно сделать с помощью рекурсивной функции, например так:

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

— ETHproductions
источник
Могли бы сэкономить несколько байтов +x?'##':' 'вместо" #"[x].repeat(2)
— Hedi
@ Хэди, спасибо, я знал, что есть путь в гольф.
— ETHproductions
2
Не могли бы вы напрямую проверить биты, x.charCodeAt()а не преобразовать их в двоичный файл? (Я думаю, это сэкономило бы около 8 байт.)
— Арно
2
Ваш алгоритм сжатия звучит почти криптографически .
— Джастин
1
@ Джастин Черт, я как раз собирался это прокомментировать.
— user253751
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)

— Мартин Розенау
источник
1
Приятно. Нам все еще не хватает 68000 ответов, но этот становится все ближе. :-)
— Арно
objdump -dwВывод - это хороший способ показать необработанный двоичный файл, поскольку вы видите, какие байты являются какой инструкцией. Я сделал это для ответов gcd и adler32 . (А также включая закомментированный исходный код для людей, чтобы попробовать себя.)
— Питер Кордес
8

Python, 223 179 байт

Второй подход:

f=lambda n:'\n'.join(''.join(2*' #'[int(d)]for d in bin(int('0c0052000100908023e003e00ff81ffc1ffc3ffe3fde1fdc1fbc0ff807f001c0'[i:i+4],16))[2:].zfill(16))*n for i in range(0,64,4))

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

Вместо того, чтобы создавать список строк на лету, существует жестко закодированная шестнадцатеричная строка, которая индексируется и преобразуется в двоичную; затем каждая двоичная цифра превращается в либо, ' 'либо '#', которая дублируется и объединяется ... и т. д.

Первый подход:

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, затем объединяются с помощью новых строк.

— Hactar
источник
Вы можете сохранить байт, переключившись на распечатку развернутого генератора, а не на соединение '\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))). Кроме того, вам не нужно считать байты, необходимые для присвоения лямбда-имени. Таким образом, ваш счет может быть 176.
— Морган Трепп
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
        ####                            ####                        
  ##  ##    ##                    ##  ##    ##                  
              ##                              ##                    
##    ##        ##              ##    ##        ##              
    ##      ##########              ##      ##########          
            ##########                      ##########          
        ##################              ##################      
      ######################          ######################    
      ######################          ######################    
    ##########################      ##########################  
    ################  ########      ################  ########  
      ##############  ######          ##############  ######    
      ############  ########          ############  ########    
        ##################              ##################      
          ##############                  ##############        
              ######                          ######
— cleblanc
источник
Вы можете сохранить несколько байтов, используя десятичные представления этих шестнадцатеричных чисел, чтобы потерять 0x.
— Медь
@Copper Спасибо, мне удалось побрить немало байтов, используя вместо putchar запись.
— cleblanc
6

/// , 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)
Большая часть кода гарантирует, что бомбы напечатаны бок о бок, а не друг на друга.

— boboquack
источник
5

CJam , 66 байт

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

Попробуйте онлайн! (обратите внимание, что в коде есть некоторые непечатаемые символы.)

Бомба, закодированная как двоичное число с использованием 1 для пробелов (начальный пробел как 1 гарантирует, что нам не нужно заполнять двоичные представления), транспонируется, а затем преобразуется в строку в base-136 (что дает самую короткую строку без широких символов). Эти шаги можно сыграть здесь .

Этот ответ затем изменяет кодировку, основной трюк заключается в том, чтобы повторить бомбу перед переносом, эффективно объединяя каждую линию бомбы сразу. Символы в каждой строке можно затем удвоить, добавив символы новой строки для окончательного вывода.

— Линус
источник
5

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);
— Titus
источник
2
Вы можете сэкономить 2 байта, используя разрыв строки в начале, а не завершающий, и, таким образом, не располагая пробелом после эха, и используя фактический разрыв строки вместо символа \n.
— user59178
@ user59178 Я знаю. не так многословно, пожалуйста.
— Тит
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 записей). Но вместо этого короче использовать вектор [1 2 ... 49], который будет одинаково действителен благодаря модульной индексации. Таким образом, декодирование по длине прогона

49:                                       Y"

Сформированный вектор containis на прогоны 1, 2... 49, в общей сложности 512 записей. Это преобразовано в матрицу 16 × 32:

                                            32e!

и используется в качестве модульных индексов в строке ' #'для производства одной бомбы:

                                                ' #'w)

Наконец, горизонтальное повторение с помощью коэффициента, заданного входными данными, дает желаемый результат:

                                                      liX"
— Луис Мендо
источник
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

Это в идеоне

(Я понял, что прямое кодирование исходной бомбы в базе 36 было сделано для более короткого кода в Python.)

Строка была сформирована обработкой пробелов как 1 с и хэшей как 0, а затем преобразованием в основание 36. Затем программа преобразует обратно в двоичный файл и срезы в длину 16 (со смещением 2 для '0b' в начале Python. двоичная строка), преобразует в двойные пробелы и двойные хэши, объединяет их, повторяет строковое 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

Это в идеоне

Почти порт моего желе ответа .

— Джонатан Аллан
источник
Неэффективно хорошо, если оно короче. Ницца +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, эффективно следуя за транспозицией (то есть экономит байты при разрезании заданной строки). Результирующая строка объединяется, биты заменяются на удвоенные или #, и соединяются в одиночную строку.

— Линус
источник
1
Вы можете сбросить ведущий ноль со своего базового номера 36.
— Джонатан Аллан
@JonathanAllan: Хороший улов. Я думал, что это было Oпо какой-то причине ...
— Линус
4

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

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

Попробуйте онлайн!

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

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

Попробуйте онлайн!

Это segfaults, если параметр командной строки не указан.

— ceilingcat
источник
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 одинаковых символов), затем повторяет бомбу столько раз, сколько необходимо, прежде чем, наконец, дублировать каждый символ.

— Нил
источник
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

Посмотрел на Hex список номеров, но, похоже, он не сохранил достаточно, чтобы стоить того. Я надеялся, что смогу сыграть в код, но, похоже, достиг такого уровня, насколько я могу, с этим подходом. Любые дополнительные подсказки с благодарностью получены.

РЕДАКТИРОВАТЬ

-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
        ####                            ####                    
  ##  ##    ##                    ##  ##    ##                  
              ##                              ##                
##    ##        ##              ##    ##        ##              
    ##      ##########              ##      ##########          
            ##########                      ##########          
        ##################              ##################      
      ######################          ######################    
      ######################          ######################    
    ##########################      ##########################  
    ################  ########      ################  ########  
      ##############  ######          ##############  ######    
      ############  ########          ############  ########    
        ##################              ##################      
          ##############                  ##############        
              ######                          ######
— ElPedro
источник
" #"[e>0]*2будет работать
— Джонатан Аллан
DOH! Как я скучал по этому ??? Спасибо @ Джонатан
— ElPedro
... скобки (...)тоже могут идти (RE: согласно моему предыдущему комментарию).
— Джонатан Аллан
Вы можете снизить его до 170 сfor y in ...:print"".join(" #"[e>0]*2for e in(([0]*7+map(int,bin(y)[2:]))[-16:]))*z
— Джонатан Аллан
@Jonathan Еще раз спасибо. здесь уже поздно, поэтому я сохраню эти изменения на завтра, чтобы не испортить их полностью.
— ElPedro
3

RProgN , 210 193 байта

Сохраняя несколько байтов, переключая 0 = '' 1 = '##' на 1 = '' 0 = '', это означает, что мне не нужно добавлять дополнительные нули обратно. Кроме того, это означает, что теперь строка B64, которая раньше говорила «MAFIA», не делает этого, это печально.

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

объяснение

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

Довольно длинный, Расширение, печать и тому подобное сжатой строки составляет 105 байтов. Может быть немного более пригодным для игры в гольф, но по крайней мере это работает.

Ввод неявно в стеке, стек неявно печатается.

Выход

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

Попробуй!

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

— Ataco
источник
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-битное число переворачивается, затем кодируется как число base-36, дополняется, 0если необходимо, лидирующим символом, поэтому каждые 16 битов дают 3 байта. Объединяя эти результаты в 01c02203k07d1j81j46b4cmwcmwpa4ohobugc8o6b434w0ow. Код полностью изменяет процесс, поэтому бомбы печатаются правильно Nраз.

Tweaks

  • Сохранено 4 байта с использованием только одного цикла for
  • Сохранение байта путем печати одного символа для каждой итерации и использования строкового индекса вместо троичного
  • Сохранение байта путем сброса $jна ноль на границах строки с помощью %=. Это избавляет от скобок
  • Сохранено 2 байта с помощью $argn
— aross
источник
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 широкие символы хранятся в виде 16-битного целого числа в Windows и 32-битного в Linux, но, опять же, это не имеет отношения к текущей задаче)

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

UTF-8,

Вот версия ближе к оригинальной публикации с кодированным UTF-8 источником. Это потребляет 173 байта. Сама строка составляет 50 байтов источника. Процедура также длиннее, поскольку байты ASCII теперь хранятся с заполнением 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 для широкого символа. Ideone не жалуется, поэтому я считаю, что это хорошо.

Попробуйте это на Ideone

— claydonkey
источник
Впечатляет. Какая кодировка используется?
— DJMcMayhem
Он скомпилирован на MinGW GCC, где широким символом является uint16. Следовательно, кодирование - [16-битный тип, содержащий UTF-16 Unicode]. Тем не менее, я думаю, что, поскольку символы находятся в пределах 0xFF (16 бит), они расширены ASCII. + Так что ничего особенного
— глина клана
Извините, я немного больше узнал о кодировке и, возможно, ошибся в том, что она хранится в формате UTF-16. Пожалуйста, обратитесь к подробному ответу.
— Мишка
2

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]]
— Ник Хансен
источник
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);}

}
— Marco13
источник
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вместо печати (импорт также входит в число байтов между прочим ..); --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')

Кодирует строку в виде числа base-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'

Последующая строка является строкой в ​​кодировке base-95 со смещением 32, так что все символы попадают в диапазон ASCII, и, к счастью, нет 's, которые нужно экранировать. 3 u:получает коды символов строки, 32x-~делает каждое число xразмеченным числом и вычитает 32из него; 95#.преобразует в число base-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
        ####                            ####                            ####
  ##  ##    ##                    ##  ##    ##                    ##  ##    ##
              ##                              ##                              ##
##    ##        ##              ##    ##        ##              ##    ##        ##
    ##      ##########              ##      ##########              ##      ##########
            ##########                      ##########                      ##########
        ##################              ##################              ##################
      ######################          ######################          ######################
      ######################          ######################          ######################
    ##########################      ##########################      ##########################
    ################  ########      ################  ########      ################  ########
      ##############  ######          ##############  ######          ##############  ######
      ############  ########          ############  ########          ############  ########
        ##################              ##################              ##################
          ##############                  ##############                  ##############
              ######                          ######                          ######
— Конор О'Брайен
источник
2

BaCon , 229 227 195 байт

Вклад в бейсик ради ностальгии. Переменная «а» определяет количество бомб.

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}

Выход :

        ####                            ####                    
  ##  ##    ##                    ##  ##    ##                  
              ##                              ##                
##    ##        ##              ##    ##        ##              
    ##      ##########              ##      ##########          
            ##########                      ##########          
        ##################              ##################      
      ######################          ######################    
      ######################          ######################    
    ##########################      ##########################  
    ################  ########      ################  ########  
      ##############  ######          ##############  ######    
      ############  ########          ############  ########    
        ##################              ##################      
          ##############                  ##############        
              ######                          ######
— Питер
источник
2

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]]
— Angs
источник
2

C (Atari TOS 2.06 US), 129 124 117 113 байтов

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

При этом используется битовая карта бомбы из TOS ROM, которая немного отличается от той, о которой идет речь. Для других версий TOS вам придется изменить адрес, на который указывает *a. Обратите внимание, что некоторые эмуляторы не содержат битовую карту!

Если вы не укажете аргумент командной строки, могут отображаться несколько битовых карт высокого разрешения :-)

— ceilingcat
источник
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, были заменены на x's.
Шестнадцатеричные значения: 0008,0002,0610,1F8A,3FC1,7FC1,7FF2,FFF4,FFF8,EFF0,73F0,7FC0,3FC0,1F80,0600
поскольку SB сохраняет файлы в формате UTF-8, некоторые из них считаются как 2 или 3 байта.

— 12Me21
источник
@Arnauld Я не знаю много о SmileBASIC, но, учитывая, что есть цикл FOR K=1TO Nс INPUT N, я думаю, что он отображает количество бомб, заданных на входе. Тем не менее, я должен сказать, что, несмотря на квадратный шрифт, я считаю, что символы должны быть удвоены, чтобы соответствовать требованиям (чтобы избежать преимущества над другими ответами). Вы можете оставить текущее для более привлекательного решения, но я думаю, что вы все равно должны добавить правильное решение. Как только вы добавите это, я буду признателен за творческое использование символов UTF-8!
— HyperNeutrino
@AlexL. Да, мой комментарий был до обновления кода.
— Арно
1

Ruby 2.x (лямбда) - 157 байт

Вероятно, можно играть в гольф дальше, но мне нравится эта версия:

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

Идея, аналогичная версии (версиям) Python: разбить строку шестнадцатеричных кодированных бомб на секции по 4 символа, преобразовать в двоичную, преобразовать 1в #и 0в , удвоить каждый символ и распечатать полученный массив.

Обратите внимание, что put используется для печати массива. Это выведет массив из одной строки на элемент.

— Неркетур Камачи
источник
1

Excel VBA, 204 байта

Anonymous VBE Immediate оконная функция, которая принимает входные данные из диапазона [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

Выход

Babomb

— Тейлор Скотт
источник
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.