introduction

L' Atari ST était un ordinateur personnel assez populaire du milieu des années 80 au début des années 90, alimenté par un microprocesseur Motorola 68000. Sur cet ordinateur, le comportement par défaut du système d'exploitation pour les exceptions d'UC non capturées consistait à afficher une rangée de bombes à l'écran, comme indiqué dans l'image suivante:

_{Source: https://commons.wikimedia.org/wiki/File:Row_of_bombs.png
NB: En fonction de la version du système d'exploitation, les graphismes de la bombe peuvent varier légèrement. Mais prenons celui-ci comme référence.}

Le nombre de bombes dépend du vecteur d'exception, les plus courantes étant:

• (008 $) Erreur de bus: 2 bombes
• ($ 00c) Erreur d'adresse: 3 bombes
• (010 $) Instruction illégale: 4 bombes

Objectif

Votre objectif est d’écrire un programme ou une fonction qui imprime ou produit un art ASCII de telles bombes Atari ST.

Contribution

Un entier représentant le nombre de bombes à afficher. Votre code doit prendre en charge les valeurs les plus courantes: 2, 3 et 4. Prendre en charge moins et / ou plus de bombes est acceptable, mais il n’est ni requis ni soumis à un bonus.

Sortie

La bombe originale consiste en une tuile de 16 x 16 pixels, représentée ici à la fois en ASCII et en binaire:

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

Dans ce défi, chaque bombe ASCII doit être étirée à deux fois sa largeur d'origine pour un meilleur rendu. Par conséquent, il se composera de 16 lignes de 32 caractères, en utilisant ##pour les pixels "ON" et deux espaces pour les pixels "OFF". Toutes les tuiles de bombe doivent être mises côte à côte. Les espaces principaux sont interdits. Les espaces de fuite sont également interdits, à l'exception de ceux qui font réellement partie de la tuile bombe (c'est-à-dire les 31e et 32e colonnes) qui doivent être présents. Vous ne pouvez pas inclure plus d'un saut de ligne de tête et pas plus d'un saut de ligne de fuite.

Exemple

Vous trouverez ci-dessous la sortie de référence pour deux bombes, où les sauts de ligne obligatoires sont marqués comme \net les sauts de ligne supplémentaires tolérés sont marqués comme suit (\n):

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

(Bien entendu, d'autres formats de saut de ligne tels que \rou \r\npeuvent tout aussi bien être utilisés.)

Règles

C'est du code-golf, donc la réponse la plus courte en octets est gagnante. Les échappatoires standard sont interdites.

Gelée , 43 44 octets

+1 octet - j'ai oublié de doubler le nombre de caractères (personne non remarqué!)

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

TryItOnline

Comment?

La préparation consistait à compresser les données en tant que codage de la durée de l'image d'origine:

• Compter la longueur de chaque série de 1s (espace) ou de 0s (hachage) dans l'image, en ignorant les nouvelles lignes - génère une liste [4,2,11,1,1,...]:;
• Soustrayez un de chaque nombre - cela donne une plage de [0,15];
• Traitez ceci comme un nombre en base 16 (énumérez les valeurs v, avec index iinversé et somme 16**i*v= 19468823747267181273462257760938030726282593096816512166437);
• Convertissez ceci en base-250 [5,119,249,42,...]:;
• Carte dans la page de code de Jelly sous forme d'index: ¥vẏ)X;ndĊɓ¡ẹ3ċi}Ịɲ¡P

Maintenant, le code évalue ce nombre, mappe les lettres 1s et 0s en caractères espace et dièse *, les double, se divise en lignes et répète le nombre de fois approprié.
* en réalité, l'implémentation est effectuée modulo 2 pour économiser des octets, donc les espaces sont impairs et les hachages sont pairs:

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

Utilise le codage CP-1252 .

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

Essayez-le en ligne!

Explication

Comme l'image de sortie ne contient que 2 caractères, nous pouvons la représenter sous forme de nombre binaire.
Nous pouvons ignorer les nouvelles lignes car chaque ligne a la même longueur.
Nous pouvons ignorer le dernier caractère de chaque ligne car il est identique pour toutes les lignes.
Nous utilisons l’image la plus fine car elle occupe moins d’espace et nous pouvons facilement dupliquer chaque personnage ultérieurement.

En utilisant 1 pour représenter l' espace et 0 pour représenter #, nous obtenons le nombre binaire:

111100111111111101011011111111111111101111111011011110111111110111000001111111111000001111111100000000011111000000000001111000000000001110000000000000110000000010000111000000010001111000000100001111100000000011111110000000111111111100011111

Nous convertissons ensuite ceci en base 10 puis nous le compressons en base 214, la base maximale dans 05AB1E. Le résultat est:

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

La viande du programme comprend alors les éléments suivants:

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

Le code contient des caractères non imprimables, voici donc un xxdhexdump réversible .

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

Essayez-le en ligne.

JavaScript (ES6), 159 154 140 136 octets

Économisé beaucoup d'octets grâce à @Hedi et @Arnauld

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

C'est 104 caractères, mais (malheureusement) 136 octets UTF-8. La chaîne a été générée avec cet extrait:

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

Utiliser .replaceau lieu de [...string].mapest également long:

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

Comment ça fonctionne

Étant donné que chaque ligne des données brutes peut être représentée sous la forme d'un nombre de 16 bits, nous pouvons stocker le fichier entier dans une chaîne de 16 caractères. L'algorithme de compression prend chaque ligne binaire, le retourne et l'inverse (puisque chaque ligne de l'original se termine par un 0 , chaque ligne de la version modifiée commence par un 1 ), puis la transforme en caractère et concatène les caractères résultants. .

Pour le décompresser, nous devons extraire le charcode et transformer sa représentation binaire en une chaîne de hachages et d'espaces. Cela peut être fait avec une fonction récursive, comme ceci:

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

fprend à plusieurs reprises le dernier bit de q, en sélectionnant deux espaces s'il s'agit d'un ou deux dièses s'il s'agit de 0, puis concatène cela avec le résultat de l'exécution fdans le reste de q. Ceci est exécuté x.charCodeAt(), transformant le code de caractères dans la chaîne correcte d'espaces et de hachages.

(Il y avait beaucoup plus de drame ici avant, mais la technique d'économie de 4 octets a effacé tout cela.)

Après cela, nous pouvons simplement répéter les ntemps de chaîne et ajouter une nouvelle ligne. C'est la méthode de décompression la plus courte que j'ai trouvée, mais n'hésitez pas à suggérer des méthodes éventuellement plus courtes.

Autres tentatives de compression de la chaîne:

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

Le premier d'entre eux est de 153 octets, donc aucun d'entre eux ne se rapproche de 136 ...

Fichier .COM MS-DOS, 84 octets

D'ACCORD. Juste pour le plaisir parce que je ne peux pas battre les 50 octets ...

Essayé sous DOSbox ainsi que sous MS-DOS 6.22 dans une machine virtuelle.

Sous DOSbox, le programme fonctionne correctement, mais sous MS-DOS, le résultat ne sera pas affiché correctement, car DOS nécessite CR-LF au lieu de LF en fin de ligne.

(Cependant, la sortie est correcte.)

Une variante de 88 octets utiliserait CR-LF en fin de ligne.

Voici le fichier:

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

Le code assembleur (dans la syntaxe AT & T) ressemble à ceci:

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

--- Modifier ---

J'ai oublié de mentionner: le programme doit être démarré avec la ligne de commande suivante:

Nom du fichier COM + exactement un espace + Nombre de bombes (1-9)

Python, 223 179 octets

Deuxième approche:

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

Essayez-le sur repl.it!

Plutôt que de créer une liste de chaînes à la volée, il existe une chaîne hexadécimale codée en dur qui est indexée et convertie en binaire; alors chaque chiffre binaire est transformé en ' 'ou '#', qui est dupliqué et réuni, etc.

Première approche:

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

Essayez-le sur repl.it!

Celui-ci contient une liste codée en dur des chaînes de chaque ligne (espaces non compris) créées en dupliquant un ' 'ou '##'plusieurs fois. Pour chacune de ces chaînes, elles sont complétées par des espaces de 32 caractères au maximum, les ntemps dupliqués , puis reliées par de nouvelles lignes.

C, 250 240 208 188 octets

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

Basculer vers l'utilisation d'une fonction.

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

Testez comme ça. main(c,v)char**v; { f(atoi(v[1])); }

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

/// , 539 532 + no. des octets de bombes

Le premier /// répond, affichant 4 bombes. La fin des quatre 1 peut être remplacée par toute représentation unaire du nombre de bombes que vous souhaitez imprimer (11 pour 2, 111 pour 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

Essayez-le en ligne!

Si l'entrée doit être décimale, le code suivant contient 555 548 octets (le dernier chiffre pouvant être modifié en 1, 2, 3 ou 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

Essayez-le en ligne!

Les parties les plus importantes du code sont les suivantes:
| signifie //
ABCDEFGHIJKLMNOP signifie chaque ligne de la bombe respectivement
S signifie 2 espaces
s signifie 4 espaces
* signifie 6 espaces
q signifie 8 espaces
T signifie ## (2)
t signifie #### (4)
^ signifie ##### # (6)
r signifie ######## (8)
& signifie ################ (16) L'
essentiel du code consiste à s'assurer que les bombes sont imprimées. côte à côte, pas les uns sur les autres.

CJam , 66 octets

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

Essayez-le en ligne! (Notez qu'il y a des caractères non imprimables dans le code.)

La bombe est codée sous forme de nombre en binaire en utilisant 1 pour les espaces (le premier espace garantit que nous n’avons pas besoin de remplir les représentations binaires), transposée puis convertie en chaîne en base-136 (qui produit la chaîne la plus courte). sans caractères larges). Ces étapes peuvent être jouées ici .

Cette réponse inverse alors l'encodage, l'astuce principale étant de répéter la bombe avant de la transposer, concaténant efficacement chaque ligne de la bombe à la fois. Les caractères de chaque ligne peuvent ensuite être doublés avec des nouvelles lignes insérées pour la sortie finale.

PHP, 138 104 + 32 = 136 octets

Je n'avais jamais pensé qu'il files'agissait d'un coffre-fort binaire. J'espère seulement que j'aurais trouvé un moyen plus intéressant de stocker les données; mais rien que j'ai essayé de battre binaire brut.

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

• lire les données binaires du fichier, décompresser de little endian 16bit en tableau d'int
• Boucle dans tableau: impression binaire à 16 chiffres en chaîne, remplacer 0par 2 espaces, 1avec ##,
  répéter le $argv[1]temps, résultat d'impression + nouvelle ligne

courir avec -r

données binaires dans le fichier b:

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

code pour générer le fichier:

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

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

Essayez-le en ligne!

Explication

Le code utilise une version pré-compressée de la matrice binaire 16 × 16. La pré-compression (ne faisant pas partie du programme) a utilisé deux étapes:

1. Encodage de la longueur de la matrice lue dans l'ordre des lignes principales (d'abord en travers, puis en bas).
2. Les longueurs de plage résultantes vont de 1 à 16, ainsi le vecteur des longueurs inférieures à 1 a été converti de la base 16 à la base 94 (pour utiliser tous les codes ASCII imprimables, à l'exception des guillemets simples, qui ne sont pas utilisés car ils auraient besoin d'un caractère d'échappement).

La chaîne comprimée,

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

est décompressé de la base 94 à la base 16:

                                   F16Za

Le vecteur obtenu des longueurs de parcours plus 1 est multiplié par 2:

                                        QE

pour effectuer l'étirement horizontal.

Le vecteur de run-lenghts contient 49 valeurs. Les numéros originaux à répéter avec ces longueurs doivent être [0 1 0 1 ... 0](49 entrées). Mais au lieu de cela, il est plus court d'utiliser le vecteur [1 2 ... 49], qui sera également valide grâce à l'indexation modulaire. Donc, le décodage en longueur est

49:                                       Y"

Le vecteur généré containis les pistes de 1, 2... 49, pour un total de 512 entrées. Ceci est reformé dans une matrice 16 × 32:

                                            32e!

et utilisé comme index modulaire dans la chaîne ' #'pour produire une seule bombe:

                                                ' #'w)

Enfin, la répétition horizontale par un facteur donné par l'entrée produit le résultat souhaité:

                                                      liX"

Python 2: 143 octets

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

C'est chez ideone

(J'ai réalisé que l'encodage direct de la bombe d'origine en base 36 permettait un code plus court en Python.)

La chaîne a été formée en traitant les espaces comme des 1 et les hachages comme des 0, puis en les convertissant en base 36. Le programme reconvertit ensuite en binaire et en tranches en longueurs de 16 (avec un décalage de 2 pour le "0b" à l'avant de Python). chaîne binaire), convertit en doubles espaces et doubles hachages, les associe, répète les ntemps de chaîne et imprime.

Précédent: Python 2, 169 166 163 octets

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

C'est chez ideone

Presque un port de ma réponse de gelée .

Python 2.7, 144 141 octets

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

La bombe est écrite en binaire avec 1 pour l'espace, la première 1 évite d'avoir à compléter des représentations binaires. La bombe est transposée (un peu comme dans ma réponse CJam ) et stockée dans la base 36.

Le programme décode la bombe en binaire et itère les bits d'une étape de 16 après la transposition (qui consiste à enregistrer des octets sur le découpage d'une ligne donnée). La ligne résultante est concaténée, les bits sont remplacés par doublé ou #, et joints en une seule chaîne.

C (gcc) , 216 204 183 165 134 octets

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

Essayez-le en ligne!

Écrit en tant que programme autonome ( 201 183 151 octets)

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

Essayez-le en ligne!

Cette erreur de segmentation si un paramètre de ligne de commande n'est pas fourni.

Lot, 415 octets

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

Remarque: la ligne set s=se termine par 5 espaces. Accepte le compte en tant que paramètre de ligne de commande. Boucle simplement à travers chaque ligne de la bombe (très légèrement compressé en supprimant des séquences de 5 caractères identiques), puis répète la bombe autant de fois que nécessaire avant de dupliquer finalement chaque caractère.

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

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

Regardé Hex pour la liste de numéros mais cela ne sembla pas économiser assez pour que cela vaille la peine. J'espérais pouvoir jouer avec le code mais semble avoir été aussi loin que possible avec cette approche. Toute astuce supplémentaire reçue avec gratitude.

MODIFIER

-1 en changeant e==1pour e>0. J'oublie toujours celui-là.

-2 en ignorant la longueur de la chaîne binaire, en ajoutant des 7 à 0 et en ne prenant que les 16 derniers éléments. Fonctionne car il n’ya jamais plus de 7 premiers 0.

-4 parce que maintenant que j'ai perdu la deuxième référence à la variable b, je peux l'utiliser bin(y)[2:]directement dans la fonction map en la passant au-dessous du chiffre magique 200 :-)

-8 en utilisant l'affectation de tranche sur la deuxième liste. J'ai appris quelque chose de nouveau ce soir.

-3 avec merci à Jonathan

-2 en utilisant c=d=([0]*7+map(int,bin(y)[2:]))[-16:]au lieu d'avoirc=d;

-2 encore grâce à @Jonathan

-24 avec @Linus

Sortie

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

RProgN , 210 193 octets

Enregistré quelques octets en passant de 0 = '' 1 = '##' à 1 = '' 0 = '', cela signifie que je n'ai pas besoin de rajouter les zéros supplémentaires. En outre, cela signifie que la chaîne B64 qui disait "MAFIA" ne le fait pas. C'est triste.

'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

Explication

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

Assez long, le développement, l'impression et tel de la chaîne compressée est 105 des octets. Peut-être un peu plus golfable, mais au moins ça marche.

L'entrée est implicitement sur la pile, la pile est implicitement imprimée.

Sortie

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

Essayez le!

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

Remarque: utilise le codage Windows-1252

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

Courez comme ça:

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

Ou en utilisant l'encodage IBM-850 (135 octets et un résultat plus joli):

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

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

Explication

Cela ne fait pas de binaire et ne nécessite pas de fichier externe.

Chaque numéro de 16 bits est inversé, puis codé en tant que nombre en base 36, complété par un interligne 0si nécessaire, de sorte que tous les 16 bits donnent 3 octets. Concaténer ces résultats en 01c02203k07d1j81j46b4cmwcmwpa4ohobugc8o6b434w0ow. Le code inverse le processus pour que les bombes soient imprimées correctement Nfois.

Tweaks

• 4 octets enregistrés en utilisant un seul for-loop
• Enregistré un octet en imprimant un seul caractère pour chaque itération et en utilisant un index de chaîne au lieu de ternaire
• Enregistré un octet en réinitialisant $jà zéro les limites de ligne avec %=. Cela supprime les parenthèses
• 2 octets enregistrés en utilisant $argn

GCC C 129 octets

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

En une ligne:

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

Courir avec:

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

Compilez la source en tant que ISO8859-x (ASCII).

NB óÿÿþÿoÜüðààÀÀ! ÀCàCðøþ? devrait contenir les codes ASCII invisibles, mais il a été cassé à cause de la manière dont StackExchange présente son contenu. Veuillez consulter le lien ideaone pour un codage de test correct. Sinon, la chaîne ASCII d'origine est disponible à l' adresse : https://github.com/claydonkey/AtariBombs/blob/master/ISO8859_REPR2.txt.

Explication

D'abord une conversion de la représentation hexadécimale des bombes [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] en UTF-8 (dans le Version UTF-8, le compilateur stocke la chaîne au format Wide Char Array - 2 ou 4 octets pour chaque caractère au moment de l’exécution, mais c’est académique). Alors que les caractères UTF-8 seraient stockés sous forme de 2 à 4 octets, ces valeurs sont toutes conformes à la norme ISO-8859-1 (ASCII) et ne nécessitent donc qu'un octet. Il est également sûr d’être stocké en tant que ISO-8859-x (il n’existe pas de valeurs 0x8_ ou 0x9_). Par conséquent, le texte consomme 32 octets dans ISO-8859 et la routine consomme 135 octets au total.

(NB: les caractères larges sont stockés sous forme de nombre entier 16 bits dans Windows et 32 ​​bits sous Linux, mais là encore, cela n’a aucune incidence sur la tâche à accomplir)

Avertissement: tous les caractères ne sont pas affichables (les caractères de contrôle inférieurs à 0x20). Ils sont toutefois toujours présents. La plupart des pages Web sont utf-8 / 8859/1253 ( https://w3techs.com/technologies/overview/character_encoding/all ), donc je pense que c'est légitime (le fait de changer toutes les valeurs inférieures à 0x20 en ASCII imprimable devrait résoudre ce problème).

UTF-8

Voici la version la plus proche de la publication d'origine avec la source codée UTF-8. Cela consomme 173 octets. La chaîne elle-même étant à 50 octets de la source. La routine est également plus longue car les octets ASCII sont maintenant stockés avec des 0 de remplissage pour les caractères larges 16 bits / 32 bits et doivent être décalés au lieu d'être convertis en uint16_t comme ci-dessus. Je l'ai gardé comme il peut être vérifié avec ideone qui utilise le codage 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)?"  ":"##")));}

Courir avec:

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

Si vous pouvez définir la valeur implicite sur un entier 16 bits dans votre fournisseur, vous pouvez omettre la déclaration de type wchar_t du caractère large. Ideone ne se plaint pas alors je pense que c'est bon d'y aller.

Essayez sur ideone

Haskell, 155 octets

En fonction du type Int -> String:

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

L'impression directement sur IO coûtera 5 octets (ou 6 si nous préférons retourner IO ()plutôt que 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 octets

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

concatène chaque x à lui-même et provoque un débordement de p pour terminer chaque ligne.

Java, 228 octets

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 octets

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

Encode la chaîne en tant que nombre base 95, incrémente chaque chiffre de 32, puis la représente par une chaîne ascii.

Explication

Ceci est composé de deux parties principales. Il y a la construction de la bombe et la répétition réelle. Parlons pour le moment de la bombe b. Ensuite, le code ressemble à:

|:@;@#&(b)

Appelé avec entrée k, cela équivaut à:

|: ; (k#b)

best une bombe en boîte, en k#bfait des krépétitions b, l' ;aplatit verticalement et |:transpose le résultat. (La bombe best elle-même construite transposée.)

Maintenant, voici la bombe:

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

La chaîne suivante est une chaîne codée en base 95 avec un décalage de 32, de sorte que tous les caractères entrent dans la plage ASCII et, heureusement, il n’existe aucun 's à échapper. 3 u:récupère les codes de caractère de la chaîne, attribue à 32x-~chaque nombre un xnombre étendu et en soustrait 32; 95#.convertit en un nombre de base 95 et le 2#.invconvertit en un tableau de chiffres binaires. J'ai ajouté un début 1au binaire afin d'en faire un nombre solide, alors je l'enlève avec }.. Je façonne le tableau dans une table 16x16 avec 16 16$puis le transpose en utilisant |:. (Golf possible pour plus tard: transposez la chaîne codée littérale.) 2#Duplique chaque caractère en largeur. Nous nous retrouvons avec une table de 0s et 1s.' #'{~cartes 0s à ' 'et 1à '#'. Comme cela, nous nous retrouvons avec notre bombe.

Cas de test

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

BaCon , 229 227 195 octets

Une contribution en BASIC par nostalgie. La variable 'a' détermine le nombre de bombes.

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}

Sortie :

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

Haskell, 191 181 octets

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

C (Atari TOS 2.06 US), 129 124 117 113 octets

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

Ceci utilise le bitmap de bombe de la ROM TOS, qui est légèrement différent de celui de la question. Pour les autres versions de TOS, vous devrez ajuster l'adresse indiquée par *a. Notez que certaines roms de l'émulateur n'incluent pas le bitmap de la bombe!

Si vous ne fournissez pas d'argument en ligne de commande, plusieurs bombes bitmap haute résolution peuvent s'afficher :-)

C ++ 11, 252 octets

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

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

(Capture d'écran de la version sans doublons de caractères)
SB ayant une police carrée, doubler les caractères n'a pas de sens (et ne rentre pas à l'écran)
Les caractères non-ASCII ont été remplacés par les caractères x's.
Valeurs Hex: 0008,0002,0610,1F8A,3FC1,7FC1,7FF2,FFF4,FFF8,EFF0,73F0,7FC0,3FC0,1F80,0600
comme SB enregistre des fichiers au format UTF-8, certains d’entre eux comptent pour 2 ou 3 octets.

Ruby 2.x (lambda) - 157 octets

Peut probablement être joué au golf plus loin, mais j'aime bien cette version:

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

Idée similaire à la ou aux versions python: divisez la chaîne de bombes codées en hexadécimal en sections de 4 caractères, convertissez-les en binaire, effectuez la traduction 1en #et 0à , doublez tous les caractères et imprimez le tableau obtenu.

Notez que met est utilisé pour imprimer le tableau. Cela imprimera le tableau une ligne par élément.

Excel VBA, 204 octets

Fonction de fenêtre immédiate VBE anonyme qui prend des entrées de la plage [A1]et les envoie à l'objet 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

Sortie