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 \n
et 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 \r
ou \r\n
peuvent 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.
Réponses:
Gelée ,
4344 octets+1 octet - j'ai oublié de doubler le nombre de caractères (personne non remarqué!)
TryItOnline
Comment?
La préparation consistait à compresser les données en tant que codage de la durée de l'image d'origine:
1
s (espace) ou de0
s (hachage) dans l'image, en ignorant les nouvelles lignes - génère une liste[4,2,11,1,1,...]
:;[0,15]
;v
, avec indexi
inversé et somme16**i*v
=19468823747267181273462257760938030726282593096816512166437
);[5,119,249,42,...]
:;¥vẏ)X;ndĊɓ¡ẹ3ċi}Ịɲ¡P
Maintenant, le code évalue ce nombre, mappe les lettres
1
s et0
s 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:
la source
05AB1E ,
57555350 octetsUtilise le codage CP-1252 .
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:
La viande du programme comprend alors les éléments suivants:
la source
Pyth,
575654535150 octetsLe code contient des caractères non imprimables, voici donc un
xxd
hexdump réversible .Essayez-le en ligne.
la source
JavaScript (ES6),
159154140136 octetsÉconomisé beaucoup d'octets grâce à @Hedi et @Arnauld
C'est 104 caractères, mais (malheureusement) 136 octets UTF-8. La chaîne a été générée avec cet extrait:
Afficher l'extrait de code
Utiliser
.replace
au lieu de[...string].map
est également long: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
prend à plusieurs reprises le dernier bit deq
, 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écutionf
dans le reste deq
. 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
n
temps 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:
Le premier d'entre eux est de 153 octets, donc aucun d'entre eux ne se rapproche de 136 ...
la source
+x?'##':' '
au lieu de" #"[x].repeat(2)
x.charCodeAt()
plutôt que de les convertir en binaire? (Je pense que cela économiserait environ 8 octets.)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:
Le code assembleur (dans la syntaxe AT & T) ressemble à ceci:
--- 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)
la source
objdump -dw
La sortie est un bon moyen de montrer le binaire brut, puisque vous voyez quels octets correspondent à quelle instruction. Je l'ai fait pour gcd et adler32 réponses. (En plus d'inclure le code source commenté pour que les gens puissent s'essayer eux-mêmes.)Python,
223179 octetsDeuxième approche:
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:
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, lesn
temps dupliqués , puis reliées par de nouvelles lignes.la source
'\n'
. Ainsi,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)))
. De plus, vous n'avez pas à compter les octets nécessaires pour attribuer un nom à la lambda. Donc, votre score peut être 176.C,
250240208188 octetsBasculer vers l'utilisation d'une fonction.
Testez comme ça.
main(c,v)char**v; { f(atoi(v[1])); }
la source
0x
./// ,
539532 + no. des octets de bombesLe 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)
Essayez-le en ligne!
Si l'entrée doit être décimale, le
codesuivant contient555548 octets (le dernier chiffre pouvant être modifié en 1, 2, 3 ou 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.
la source
CJam , 66 octets
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.
la source
PHP,
138104 + 32 = 136 octetsJe n'avais jamais pensé qu'il
file
s'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.0
par 2 espaces,1
avec##
,répéter le
$argv[1]
temps, résultat d'impression + nouvelle lignecourir avec
-r
données binaires dans le fichier
b
:code pour générer le fichier:
la source
\n
.MATL ,
6463605958 octetsEssayez-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:
La chaîne comprimée,
est décompressé de la base 94 à la base 16:
Le vecteur obtenu des longueurs de parcours plus 1 est multiplié par 2:
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 estLe 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:et utilisé comme index modulaire dans la chaîne
' #'
pour produire une seule bombe:Enfin, la répétition horizontale par un facteur donné par l'entrée produit le résultat souhaité:
la source
Python 2: 143 octets
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
n
temps de chaîne et imprime.Précédent: Python 2,
169 166163 octetsC'est chez ideone
Presque un port de ma réponse de gelée .
la source
Python 2.7,
144141 octetsLa 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.la source
O
pour une raison quelconque ...C (gcc) ,
216 204 183 165134 octetsEssayez-le en ligne!
Écrit en tant que programme autonome (
201 183151 octets)Essayez-le en ligne!
Cette erreur de segmentation si un paramètre de ligne de commande n'est pas fourni.
la source
Lot, 415 octets
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.la source
Python 2,
206205203199191188186184160 octetsRegardé 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==1
poure>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
la source
" #"[e>0]*2
travaillera(...)
peuvent aussi aller (RE: par mon commentaire précédent).for y in ...:print"".join(" #"[e>0]*2for e in(([0]*7+map(int,bin(y)[2:]))[-16:]))*z
RProgN ,
210193 octetsEnregistré 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.
Explication
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!
la source
PHP,
144140139138136 octetsRemarque: utilise le codage Windows-1252
Courez comme ça:
Ou en utilisant l'encodage IBM-850 (135 octets et un résultat plus joli):
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
0
si nécessaire, de sorte que tous les 16 bits donnent 3 octets. Concaténer ces résultats en01c02203k07d1j81j46b4cmwcmwpa4ohobugc8o6b434w0ow
. Le code inverse le processus pour que les bombes soient imprimées correctementN
fois.Tweaks
$j
à zéro les limites de ligne avec%=
. Cela supprime les parenthèses$argn
la source
GCC C 129 octets
ISO8859 / ASCII
En une ligne:
Courir avec:
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.
Courir avec:
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
la source
Haskell, 155 octets
En fonction du type
Int -> String
:L'impression directement sur IO coûtera 5 octets (ou 6 si nous préférons retourner
IO ()
plutôt queIO [()]
):la source
C, 175 octets
concatène chaque x à lui-même et provoque un débordement de p pour terminer chaque ligne.
la source
Java, 228 octets
la source
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 octets ) Outre l'utilisation d'un Java 8 lambda, j'ai réduit davantage d'octets en modifiant: la position de lax=16
(et remplacéewhile
parfor
); 2x==0
à<1
; renvoyers
au lieu de l’imprimer (les importations font également partie du nombre d’octets btw ..);--x>=0
àx-->0
. Toujours, bonne réponse, alors +1!J, 89 octets
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 à:Appelé avec entrée
k
, cela équivaut à:b
est une bombe en boîte, enk#b
fait desk
répétitionsb
, l';
aplatit verticalement et|:
transpose le résultat. (La bombeb
est elle-même construite transposée.)Maintenant, voici la bombe:
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 unx
nombre étendu et en soustrait32
;95#.
convertit en un nombre de base 95 et le2#.inv
convertit en un tableau de chiffres binaires. J'ai ajouté un début1
au binaire afin d'en faire un nombre solide, alors je l'enlève avec}.
. Je façonne le tableau dans une table 16x16 avec16 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 de0
s et1
s.' #'{~
cartes0
s à' '
et1
à'#'
. Comme cela, nous nous retrouvons avec notre bombe.Cas de test
la source
BaCon ,
229227195 octetsUne contribution en BASIC par nostalgie. La variable 'a' détermine le nombre de bombes.
Sortie :
la source
Haskell,
191181 octetsla source
C (Atari TOS 2.06 US),
129 124 117113 octetsCeci 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 :-)
la source
C ++ 11, 252 octets
la source
SmileBASIC, 127 octets
(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.
la source
FOR K=1TO N
avecINPUT N
, je pense que cela affiche le nombre de bombes données dans l'entrée. Cependant, je dois dire que malgré la police carrée, je pense que les caractères doivent toujours être doublés pour rester cohérents avec les exigences (pour éviter un avantage sur d’autres réponses). Vous pouvez conserver la solution actuelle pour une solution plus esthétique, mais je pense que vous devriez tout de même ajouter une solution correcte. Une fois que vous l'aurez ajouté, je procéderai au vote positif pour l'utilisation créative des caractères UTF-8!Ruby 2.x (lambda) - 157 octets
Peut probablement être joué au golf plus loin, mais j'aime bien cette version:
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
1
en#
et0
à, 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.
la source
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 ActiveSheetSortie
la source