Giriş

Atari ST Motorola 68000 mikroişlemcisi tarafından desteklenmektedir 90'ların başındaki çağına ortalarında 80 den ziyade popüler kişisel bilgisayar oldu. Bu makinede, yakalanmayan CPU istisnaları için işletim sisteminin varsayılan davranışı, aşağıdaki resimde gösterildiği gibi, ekranda bir sıra bomba göstermekti:

_{Kaynak: https://commons.wikimedia.org/wiki/File:Row_of_bombs.png
Not: İşletim sistemi versiyonuna bağlı olarak, bomba grafikleri biraz değişebilir. Ama bunu referans olarak alalım.}

Bombaların sayısı istisna vektörüne bağlıdır, en yaygın olanları:

• (008 $) Otobüs Hatası: 2 bomba
• ($ 00c) Adres Hatası: 3 bomba
• (010 $) Yasadışı Eğitim: 4 bomba

Hedef

Amacınız, bu tür Atari ST bombalarının ASCII sanatını basan veya çıkaran bir program veya işlev yazmaktır.

Giriş

Görüntülenecek bomba sayısını gösteren bir tam sayı. Kodunuz en yaygın değerleri desteklemelidir: 2, 3 ve 4. Daha az ve / veya daha fazla bombanın desteklenmesi iyi, ancak ne gerekli ne de bonusa tabi değil.

Çıktı

Orijinal bomba, burada hem ASCII hem de binary'de temsil edilen 16x16 piksel bir karodan oluşuyor:

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

Bu zorlukla, her ASCII bombası daha iyi bir görüntü elde etmek için orijinal genişliğinin iki katı kadar uzatılmalıdır. Bu nedenle, ##'ON' piksel için ve 'OFF' piksel için iki boşluk kullanan 16 karakterden oluşan 32 karakterden oluşacaktır . Tüm bomba döşemeleri yan yana koyulmalı. Önde gelen boşluklar yasaktır. Firar boşlukları da, bomba döşemesinin bir parçası (yani, 31 ve 32. sütunlar) olması gerekenler dışında yasaktır . Birden fazla önde gelen satır sonu ve birden fazla satır sonunu da dahil edemezsiniz.

Örnek

Aşağıda, zorunlu satır sonları olarak işaretlenmiş \nve fazladan satır sonları olarak işaretlenmiş iki bomba için referans çıktısı verilmiştir (\n):

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

(Elbette, diğer satır sonu gibi biçimlendirir \rya \r\nda sadece kullanılabilir.)

kurallar

Bu kod golf, yani bayt cinsinden en kısa cevap kazanır. Standart boşluklar yasaktır.

Jöle , 43 44 bayt

+1 bayt - karakterleri ikiye katlamayı unuttum (kimsenin farkına varamadı!)

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

TryItOnline

Nasıl?

Hazırlık, verileri orijinal görüntünün işlem uzunluğu kodlaması olarak sıkıştırmaktı:

• Görüntüdeki her 1s (boşluk) veya 0s (karma) değerinin uzunluğunu sayın, yeni satırları yok sayarak - bir liste verir [4,2,11,1,1,...]:;
• Her sayıdan bir tane çıkartın - bu bir aralık verir [0,15];
• Bunu bir taban-16 sayı olarak ele alın (değerleri numaralandırın, vindeks iters ve toplam 16**i*v= 19468823747267181273462257760938030726282593096816512166437);
• Bunu base-250'ye dönüştürün [5,119,249,42,...]:;
• Jelly'in kod sayfasını indeks olarak eşleyin: ¥vẏ)X;ndĊɓ¡ẹ3ċi}Ịɲ¡P

Şimdi kod bu sayıyı değerlendirir, 1s ve 0s'yi boşluk ve karma karakterlere * eşler, her birini ikiye böler, satırlara böler ve her birini uygun sayıda tekrarlar.
* Aslında uygulama bayt kurtarmak için modulo 2 yapılır, bu yüzden boşluk tuhaf ve hash bile olur:

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

CP-1252 kodlamasını kullanır .

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

Çevrimiçi deneyin!

açıklama

Çıktı görüntüsü sadece 2 karakterden oluştuğu için onu ikili sayı olarak gösterebiliriz.
Her satır aynı uzunlukta olduğu için yeni satırları görmezden gelebiliriz.
Her satırın son karakterini tüm satırlar için olduğu gibi görmezden gelebiliriz.
Daha az yer kapladığından daha ince görüntü kullanıyoruz ve daha sonra her bir karakteri kolayca kopyalayabiliyoruz.

Kullanılması 1 temsil etmek boşluk ve 0 temsil etmek # biz ikili sayı elde:

111100111111111101011011111111111111101111111011011110111111110111000001111111111000001111111100000000011111000000000001111000000000001110000000000000110000000010000111000000010001111000000100001111100000000011111110000000111111111100011111

Daha sonra bunu üs-10'a dönüştürüyoruz ve daha sonra 05AB1E'deki azami taban olan 214 tabanına sıkıştırıyoruz. Bunun sonucu:

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

Programın eti daha sonra aşağıdakilerden oluşur:

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

Kod yazdırılamayan karakterler içeriyor, bu yüzden geri dönüşümlü bir xxdhexdump var.

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

Çevrimiçi deneyin.

JavaScript (ES6), 159 154 140 136 bayt

@Hedi ve @Arnauld sayesinde çok sayıda bayt kaydedildi

n=>[..."ￏﾵｿﻶ쀇쀇考萃쐇숇ﱿ"].map(x=>(f=q=>q?(q&1?"  ":"##")+f(q>>1):"")(x.charCodeAt()).repeat(n)).join`
`

Bu 104 karakter, fakat (ne yazık ki) 136 UTF-8 bayt. Dize bu snippet ile oluşturuldu:

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(","))

.replaceBunun yerine kullanmak [...string].mapeşit derecede uzun:

n=>"ￏﾵｿﻶ쀇쀇考萃쐇숇ﱿ".replace(/./g,x=>(f=q=>q?(q&1?"  ":"##")+f(q>>1):"")(x.charCodeAt()).repeat(n)+`
`)

Nasıl çalışır

Ham verinin her satırı 16 bitlik bir sayı olarak temsil edilebildiğinden, tüm dosyayı 16 karakterli bir dizgide saklayabiliriz. Sıkıştırma algoritması her ikilik satırı alır, çevirir ve tersine çevirir (orijinaldeki her satır 0'da bittiğinden , değiştirilen sürümdeki her satır şimdi 1 ile başlar ), sonra bir karaktere dönüşür ve elde edilen karakterleri birleştirir .

Sıkıştırmak için, kod kodunu çıkarmamız ve ikili gösterimini bir karma çizgiler ve boşluklara dönüştürmemiz gerekir. Bu gibi, özyinelemeli bir işlev ile yapılabilir:

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

fart arda son biti alır, qeğer 0 ise 1 veya iki karma ise iki boşluk seçer, sonra fkalanını çalıştırmanın sonucu ile birleştirir q. Bu, x.charCodeAt()char-code'u doğru boşluk ve karma dizgiye çevirerek devam eder.

(Daha önce burada çok daha fazla dram vardı, ancak 4 baytlık tasarruf tekniği hepsini siler.)

Bundan sonra, sadece string nzamanları tekrarlayabilir ve yeni bir satır ekleyebiliriz. Bu bulduğum en kısa dekompresyon yöntemidir, ancak olası herhangi bir kısa yöntemi önermekten çekinmeyin.

Dizeyi sıkıştırmak için diğer girişimler:

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

Bunlardan ilki 153 bayttır, yani hiçbiri 136'ın yanına gelemez ...

MS-DOS .COM dosyası, 84 bayt

TAMAM. Sadece eğlence için, çünkü 50 baytı yenemiyorum ...

DOSbox ve MS-DOS 6.22 altında sanal bir makinede denendi.

DOSbox altında program iyi çalışıyor ancak gerçek MS-DOS altında, DOS satır sonunda LF yerine CR-LF gerektirdiğinden çıktı düzgün görüntülenmiyor.

(Ancak çıktı doğru.)

88 baytlık bir değişken, satırın sonunda CR-LF kullanır.

İşte dosya:

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

Assembler kodu (AT&T sözdiziminde) şöyle görünür:

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

--- Düzenle ---

Söylemeyi unuttum: Program aşağıdaki komut satırından başlatılmalıdır:

COM dosyasının adı + tam olarak bir boşluk karakteri + Bomba sayısı (1-9)

Python, 223 179 bayt

İkinci yaklaşım:

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

Tekrar dene!

Anında dizelerin bir listesini oluşturmak yerine, dizine alınmış ve ikiliye dönüştürülmüş sabit kodlanmış onaltılık bir dize vardır; daha sonra her bir ikili rakam ya kopyalanır ya ' 'da '#'kopyalanır ve bir araya getirilir ... vs.

İlk yaklaşım:

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])

Tekrar dene!

Bu, ' 'ya '##'bir ya da birkaç kez çoğaltılarak oluşturulan her satırın dizgilerinin (kodlu boşluklar dahil değil) kodlanmış bir listesini içerir . Bu dizelerin her biri için, 32 karakter uzunluğa, kopyalanan zamana kadar boşluklarla doldurulur n, daha sonra yeni satırlara birleştirilir.

C, 250 240 208 188 bayt

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

Bir fonksiyon kullanmaya geçin.

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

Böyle test et. main(c,v)char**v; { f(atoi(v[1])); }

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

/// , 539 532 + no. bomba sayısı

İlk /// cevap, 4 bomba gösteriliyor. Son dört 1, basmak istediğiniz bomba sayısının tekil bir gösterimi ile değiştirilebilir (11 için 2, 11 için 3, 111)

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

Çevrimiçi deneyin!

Girişin ondalık olması gerekiyorsa, aşağıdaki 555 548 bayta sahiptir (son basamağın 1, 2, 3 veya 4 olarak değiştirilebilir):

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

Çevrimiçi deneyin!

Kodun en önemli kısımları:
| aracı //
ABCDEFGHIJKLMNOP bomba her satırı olarak sırasıyla
vasıtaları 2 mekanlarda S
s araçları 4 boşluk
* aracı 6 alanlarda
q aracı 8 alanlarda
T aracı ## (2)
t aracı #### (4)
^ araçlar ##### # (6)
r, ####### (8)
& anlamına gelir. ################ (16)
Kodun çoğu, bombaların yazdırıldığından emin oluyor yan yana, üst üste değil.

CJam , 66 bayt

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

Çevrimiçi deneyin! (Kodda yazdırılamayan bazı karakterler olduğunu unutmayın.)

Bombalar, boşluklar için 1 kullanarak ikilik bir sayı olarak kodlanmıştır (1 olarak baştaki boşluk, ikili gösterimleri doldurmamıza gerek kalmamasını sağlar), çevrilmiş ve daha sonra üs-136'daki dizgeye dönüştürülmüş (en kısa dizeyi üretmiştir) geniş karakterler olmadan) Bu adımlar burada oynatılabilir .

Bu cevap daha sonra şifrelemeyi tersine çevirir, asıl püf nokta, aktarmadan önce bombayı tekrarlamak ve her bombanın hattını bir kerede etkin bir şekilde birleştirmek. Her satırdaki karakterler daha sonra nihai çıktı için eklenen yeni satırlarla iki katına çıkarılabilir.

PHP, 138 104 + 32 = 136 bayt

fileİkili güvenli olduğunu hiç düşünmemiştim . Keşke verileri depolamak için daha ilginç bir yol bulsaydım; ama denediğim hiçbir şey ham ikiliyi geçmedi.

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

• İkili verileri dosyadan okuyabilir, küçük endian 16bit'ten int dizisine kadar
• dizisi döngü: dizesine baskı 16 basamaklı ikili yerine 0, 2 boşluk 1ile ##,
  tekrar $argv[1]süreleri, baskı sonucu + satır

koşmak -r

dosyadaki ikili veri b:

0000000 0c00 5200 0100 9080 23e0 03e0 0ff8 1ffc
0000010 1ffc 3ffe 3fde 1fdc 1fbc 0ff8 07f0 01c0

dosyayı oluşturmak için kod:

$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 bayt

49:',cxJr(v9hW&waHB`U=NL%)C9[$aoAN'F16ZaQEY"32e!' #'w)liX"

Çevrimiçi deneyin!

açıklama

Kod, 16 × 16 ikili matrisin önceden sıkıştırılmış bir versiyonunu kullanır. Ön sıkıştırma (programın bir parçası değil) iki adım kullandı:

1. Matrisin çalışma uzunluğu kodlaması satır ana sırada okutulur (önce aşağı, sonra aşağı).
2. Sonuçta elde edilen çalışma uzunlukları 1 ila 16 arasındadır, bu nedenle çalışma uzunlukları eksi 1'in tabanı, taban 16'dan taban 94'e dönüştürüldü (tek çıkış hariç, yazdırılmaya ihtiyaç duyacağı için kullanılmayan tek bir alıntı hariç tüm yazdırılabilir ASCII kodlarını kullanmak için).

Sıkıştırılmış dize

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

taban 94'den taban 16'ya dekompresyon yapılır:

                                   F16Za

Çalışma uzunlukları artı 1'in elde edilen vektörü 2 ile çarpılır:

                                        QE

Yatay gerdirmeyi yapmak.

Çalışma uzunlukları vektörü 49 değer içerir. Bu uzunluklarda tekrarlanacak orijinal sayılar [0 1 0 1 ... 0](49 giriş) olmalıdır. Ancak bunun yerine, [1 2 ... 49]modüler indeksleme sayesinde eşit derecede geçerli olacak vektörü kullanmak daha kısadır . Yani çalışma boyu kod çözme

49:                                       Y"

Oluşturulan vektör silsileleri containis 1, 2... 49, 512 girdilerinin toplam. Bu, 16 x 32'lik bir matrise yeniden şekillendirilir:

                                            32e!

ve ' #'tek bir bomba üretmek için dizeye modüler indeksler olarak kullanılır :

                                                ' #'w)

Son olarak, girdi tarafından verilen bir faktör tarafından yatay tekrarlama istenen sonucu verir:

                                                      liX"

Python 2: 143 bayt

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

Hiç de var ideone

(36 no'lu orjinal bombanın direk kodlanmasının Python'da daha kısa kod için yapıldığını fark ettim.)

Dize, boşlukları 1s ve hash'leri 0s olarak ele alarak ve daha sonra baz 36'ya dönüştürerek oluşturulmuştur. Program daha sonra tekrar ikili ve dilimlere 16'ya kadar uzar (Python'un önündeki '0b' için bir ofset) binary string), çift boşluklara ve çift karmalara dönüştürür, bunları birleştirir, dizi nzamanlarını tekrarlar ve yazdırır.

Önceki: Python 2, 169 166 163 bayt

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

Hiç de var ideone

Jelly cevabımın neredeyse bir limanı .

Python 2.7, 144 141 bayt

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

Bomba boşluk için 1 ile ikili olarak yazılmıştır, baştaki 1 ikili gösterimleri doldurma ihtiyacını ortadan kaldırır. Bomba çevrildi ( CJam cevabımdaki gibi ) ve 36 üssünde saklandı.

Program, bombayı ikili olarak çözer ve aktarımı (16, belirli bir satırın dilimlemesinde bayttan kurtarır) etkin bir şekilde izleyerek adımlarını tekrar eder. Elde edilen çizgi bitiştirildi, bitler iki katına çıkarıldı ya da #tek bir dizgeye birleştirildi.

C (gcc) , 216 204 183 165 134 bayt

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

Çevrimiçi deneyin!

Bağımsız bir program olarak yazılmıştır ( 201 183 151 bayt)

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

Çevrimiçi deneyin!

Bir komut satırı parametresi sağlanmazsa bu segfaults.

Toplu iş, 415 bayt

@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:#=##%

Not: Satır set s=5 boşlukta bitiyor. Sayımı komut satırı parametresi olarak kabul eder. Basitçe bombanın her bir çizgisinde dolaşır (5 özdeş karakterin hareketlerini kaldırarak çok az sıkıştırılır) sonra bomba, her bir karakteri çoğaltmadan önce istediğiniz kadar tekrarlar.

Python 2, 206 205 203 199 191 188 186 184 160 bayt

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

Sayı listesi için Hex'e baktım ama bu çabaya değecek kadar tasarruf edecek gibi görünmedi. Kodu aşağıya koyabileceğimi umuyordum, ancak bu yaklaşımla elimden gelenin en iyisini yaptım. Minnetle alınan diğer ipuçları.

DÜZENLE

-1 değiştirerek e==1için e>0. Bunu hep unutuyorum.

-2 ikili dizenin uzunluğunu yok sayarak, 0 0'ları hazırlayarak ve sadece son 16 elementi alarak. Asla 7'den fazla öncü 0'ın olmadığı gibi çalışır.

-4 çünkü şimdi b değişkenine yapılan ikinci referansı kaybettim bin(y)[2:], sihir 200 :-) altında alarak doğrudan harita fonksiyonunda kullanabilirim

İkinci listedeki dilim atamasını kullanarak -8. Bu akşam yeni bir şey öğrendim.

-3 @ Jonathan sayesinde

-2 kullanarak c=d=([0]*7+map(int,bin(y)[2:]))[-16:]yerinec=d;

@ @Jonathan sayesinde tekrar

-24 @Linus sayesinde

Çıktı

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

RProgN , 210 193 Bayt

0 bayt 0 = '' 1 = '##' - 1 = '' 0 = '' olarak değiştirilerek kaydedildi, bu da fazladan sıfırları geri eklememe gerek olmadığı anlamına geliyor. Ayrıca, bu, şimdi "MAFIA" demek için kullanılan B64 dizesinin yapamayacağı anlamına gelir, Bu üzücüdür.

'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

açıklama

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

Oldukça uzun, Genişleyen, basılan ve sıkıştırılmış dizgenin benzeri baytların 105'idir. Biraz daha golf oynayabilir, ama en azından işe yarıyor.

Giriş yığın üzerinde örtülü olarak, yığın örtülü olarak yazdırılıyor.

Çıktı

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

Dene!

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

Not: Windows-1252 kodlamasını kullanır

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

Bu şekilde koş:

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

Veya IBM-850 kodlamasını kullanarak (135 bayt ve daha güzel sonuç):

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

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

açıklama

Bu herhangi bir ikili işlem yapmaz ve harici bir dosya gerektirmez.

Her 16 bitlik sayı tersine çevrilir, ardından bir baz-36 sayı olarak kodlanır, 0gerekirse bir öncü ile doldurulur , böylece her 16 bit 3 bayt ile sonuçlanır. Bu sonuçları birleştirmek 01c02203k07d1j81j46b4cmwcmwpa4ohobugc8o6b434w0ow. Kod işlemi tersine çevirir, böylece bombalar doğru şekilde basılır N.

Düzenlemeler

• Yalnızca tek bir for döngüsü kullanarak 4 bayt kaydedildi
• Her yineleme için tek bir karakter yazdırarak ve üçlü yerine string dizini kullanarak bir bayt kaydedildi
• $jİle satır sınırlarını sıfıra sıfırlayarak bir bayt kaydedildi %=. Bu parantezlerden kurtulur
• Kullanarak 2 bayt kaydedildi $argn

GCC C 129 bayt

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

Bir satırda:

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

Çalıştır:

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

Kaynağı ISO8859-x (ASCII) olarak derleyin.

NB óÿÿşÿoÜüðààÀÀ! ÀCàCðøþ? görünmez ASCII Kodlarını içermelidir, ancak StackExchange'in içeriğini sunması nedeniyle kırılmıştır. Lütfen uygun test kodlaması için ideaone linkine bakınız. Alternatif ASCII String'i: https://github.com/claydonkey/AtariBombs/blob/master/ISO8859_REPR2.txt

açıklama

Öncelikle bombaların hex gösterimi [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 07 f8 0f fe 3f] 'nin UTF-8'e dönüştürülmesi (içinde UTF-8 sürümü, derleyici dizeyi Wide Char Array - çalışma zamanında her karakter için 2 veya 4 bayt olarak saklar, ancak bu akademikdir). UTF-8 karakterleri 2-4 bayt olarak saklanırken, bu değerlerin tümü ISO-8859-1 (ASCII) içindedir ve bu nedenle yalnızca 1 bayt gerektirir. Ayrıca, ISO-8859-x olarak depolanması güvenlidir (0x8_ veya 0x9_ değeri yoktur). Bu nedenle, metin ISO-8859'da 32 bayt tüketir ve rutin toplamda 135 bayt tüketir.

(NB geniş karakterli karakterler, pencerelerde 16 bit tam sayı ve linux'da 32 bit tam olarak depolanır, ancak bu, eldeki işle ilgisizdir)

Uyarı: Tüm karakterler görüntülenemez (0x20 altındaki kontrol karakterleri). Ancak bunlar hala mevcuttur. Web sayfalarının çoğu utf-8 / 8859/1253 ( https://w3techs.com/technologies/overview/character_encoding/all ) ' dır , bu nedenle okunaklı olduğunu düşünüyorum (yazdırılabilir ASCII değerinin 0x20 altındaki tüm değerleri düzeltmesi gerekir).

UTF-8

UTF-8 kodlu kaynak ile orjinal gönderilere daha yakın olan sürüm. Bu 173 bayt tüketir. Dizenin kendisi kaynağın 50 baytı. ASCII byte'ları 16bit / 32bit Wide Chars için pad 0'larla depolandığından ve yukarıdaki gibi uint16_t'ye kaydırılmak yerine kaydırılması gerektiğinden rutin de daha uzundur. UTF-8 kodlaması kullanan ideone ile doğrulanabildiği için bunu devam ettirdim.

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

Çalıştır:

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

Örtülü değerini, derleyicinizdeki bir 16 bit tam sayı olarak ayarlayabilirseniz, Geniş Karakterin wchar_t türü bildirimini çıkartabilirsiniz. Ideone şikayetçi değil bu yüzden gitmek iyi olduğunu düşünüyorum.

Deneyin üzerinde ideone

Haskell, 155 bayt

Türü olan bir işlev olarak 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]]

Doğrudan IO'ya yazdırmak 5 bayta mal olur (veya geri dönmek IO ()yerine tercih edersek 6 IO [()]):

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

C, 175 bayt

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

Her x'i bir araya getirir ve her satırı sonlandırmak için p taşması yapar.

Java, 228 bayt

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 bayt

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

Dize bir temel-95 numarası olarak kodlar, her basamağı artırır 32, sonra ascii bir dize ile temsil eder.

açıklama

Bu iki ana bölümden oluşmaktadır. Bombanın yapımı ve gerçek tekrarı var. Şimdilik bombaya atıfta bulunalım b. Sonra kod gibi görünüyor:

|:@;@#&(b)

Girdi ile çağrıldığında k, buna eşdeğerdir:

|: ; (k#b)

bkutulu bir bombadır, bu nedenle tekrarlarını k#byapar , dikey olarak yassılaştırır ve sonucu dönüştürür. (Bombanın kendisi devrik olarak inşa edilmiştir.)kb;|:b

Şimdi, işte bomba:

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

İzleyen dize 32, tüm karakterlerin ASCII aralığına girmesi için bir ofset ile temel-95 kodlu bir dizedir , ve neyse ki, 'kaçması gereken hiçbir şey yoktur . 3 u:dizgenin char kodlarını alır, 32x-~her sayıyı istenen bir sayı yapar xve 32ondan çıkarır ; 95#.bir taban-95 numarasına 2#.invdönüştürür, bir ikili basamak dizisine dönüştürür. 1İkili sayıya katı bir sayı kazandırmak için bir satır ekledim , bu yüzden çıkardım }.. Diziyi 16x16'lık bir tablo halinde biçimlendiririm ve 16 16$sonra onu kullanarak dönüştürürüm |:. (Daha sonrakiler için muhtemel golf: değişmez kodlanmış dizginin transpoze edilmesi.) 2#Her karakter genişliğinde çoğaltılır. Bir 0s ve 1s masası bıraktık .' #'{~haritaları 0s ' 've 1ile '#'. Böylece bombamız kaldı.

Test durumu

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

BaCon , 229 227 195 bayt

Nostalji adına BASIC’e bir katkı. 'A' değişkeni bomba miktarını belirler.

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}

Çıktı :

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

Haskell, 191 181 bayt

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 ABD), 129 124 117 113 bayt

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

Bu, söz konusu olandan biraz farklı olan TOS ROM'dan bomba bitmapini kullanır. TOS'un diğer sürümleri için ile gösterilen adresi ayarlamanız gerekir *a. Bazı emülatör romların bomba bitmapini içermediğine dikkat edin!

Bir komut satırı argümanı sağlamazsanız, birkaç yüksek çözünürlüklü bitmapped bomba görüntülenebilir :-)

C ++ 11, 252 bayt

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

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

(İkili karakter içermeyen sürümün ekran görüntüsü)
SB'nin kare bir fontu vardır, bu yüzden karakterlerin iki katına çıkması kötü görünür (ve ekrana sığmaz)
ASCII olmayan karakterler yerine xs.
Onaltılı değerler: 0008,0002,0610,1F8A,3FC1,7FC1,7FF2,FFF4,FFF8,EFF0,73F0,7FC0,3FC0,1F80,0600
SB dosyaları UTF-8’de sakladığından, bunlardan bazıları 2 veya 3 bayt olarak sayılır.

Yakut 2.x (lambda) - 157 bayt

Muhtemelen daha fazla golf olabilir, ancak bu sürümü seviyorum:

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

Piton versiyonu olarak benzer bir fikir (ler):, ikili 4 karakterden, din değiştirmenin bölüme onaltılık kodlanmış bomba dizesini kırmak çevirmek 1için #ve 0için , her karakteri çift ve elde edilen dizi yazdırın.

Diziyi yazdırmak için koyduğun kullanıldığına dikkat edin. Bu, diziyi eleman başına bir satır yazdırır.

Excel VBA, 204 Bayt

Anonim VBE Aralıktan girdi alan [A1]ve ActiveSheet Nesnesine çıkan anlık pencere işlevi

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

Çıktı