Le message Arecibo est un message radio interstellaire de 1974 contenant des informations de base sur l'humanité et la Terre, envoyé au groupe d'étoiles globulaire M13 dans l'espoir que l'intelligence extraterrestre puisse le recevoir et le déchiffrer ... Le message consistait en 1 679 chiffres binaires, environ 210 octets ...
Le nombre 1 679 a été choisi car il s’agit d’un semi-prime (le produit de deux nombres premiers), qui doit être disposé de manière rectangulaire en 73 rangées de 23 colonnes. La disposition alternative, composée de 23 lignes sur 73 colonnes, produit un ensemble inintelligible de caractères (comme tous les autres formats X / Y).
C'est le message avec la couleur ajoutée pour mettre en évidence ses parties séparées. La transmission binaire réelle ne contenait aucune information de couleur.
Votre tâche consiste à afficher le message Arecibo dans l’agencement exact 23x73 indiqué dans l’image. N'importe lequel de ces formats de sortie est acceptable:
- Texte, utilisant un caractère pour les uns et un autre pour les zéros (en utilisant les règles habituelles pour la séparation des lignes)
- Un tableau 2D de deux valeurs distinctes
- Une image 23x73 avec deux couleurs distinctes
- Un flux ininterrompu de 1679 éléments de deux valeurs distinctes (c’est-à-dire n’importe lequel des formats ci-dessus, mais à plat.)
- Un entier de 1679 bits. Indiquez l'ordre des bits et des octets (finalité) dans votre solution.
Pour votre commodité, voici une version copier-coller (également un exemple de sortie au format texte):
00000010101010000000000
00101000001010000000100
10001000100010010110010
10101010101010100100100
00000000000000000000000
00000000000011000000000
00000000001101000000000
00000000001101000000000
00000000010101000000000
00000000011111000000000
00000000000000000000000
11000011100011000011000
10000000000000110010000
11010001100011000011010
11111011111011111011111
00000000000000000000000
00010000000000000000010
00000000000000000000000
00001000000000000000001
11111000000000000011111
00000000000000000000000
11000011000011100011000
10000000100000000010000
11010000110001110011010
11111011111011111011111
00000000000000000000000
00010000001100000000010
00000000001100000000000
00001000001100000000001
11111000001100000011111
00000000001100000000000
00100000000100000000100
00010000001100000001000
00001100001100000010000
00000011000100001100000
00000000001100110000000
00000011000100001100000
00001100001100000010000
00010000001000000001000
00100000001100000000100
01000000001100000000100
01000000000100000001000
00100000001000000010000
00010000000000001100000
00001100000000110000000
00100011101011000000000
00100000001000000000000
00100000111110000000000
00100001011101001011011
00000010011100100111111
10111000011100000110111
00000000010100000111011
00100000010100000111111
00100000010100000110000
00100000110110000000000
00000000000000000000000
00111000001000000000000
00111010100010101010101
00111000000000101010100
00000000000000101000000
00000000111110000000000
00000011111111100000000
00001110000000111000000
00011000000000001100000
00110100000000010110000
01100110000000110011000
01000101000001010001000
01000100100010010001000
00000100010100010000000
00000100001000010000000
00000100000000010000000
00000001001010000000000
01111001111101001111000
Si votre langue, pour quelque raison que ce soit, intègre le message Arecibo, vous ne pouvez pas l'utiliser.
Bonne chance!
UPDATE: J'ai accepté la réponse 05AB1E car c'était la première à être plus courte que le message d'origine. Ne laissez pas cela vous dissuader de nouvelles solutions.
MISE À JOUR 2019-09-09: Réponse acceptée déplacée vers une nouvelle réponse 05AB1E, car elle obsolète la réponse précédente 05AB1E. Le même point va comme la mise à jour précédente; les nouvelles solutions sont toujours les bienvenues.
Réponses:
05AB1E , 182 octets
Essayez-le en ligne! (utilise
1pour 0 et0pour 1, comme le permet la question).Essayez-le en ligne! (5 octets de plus,
0pour 0 et1pour 1, ajout de nouvelles lignes pour la lisibilité).La majeure partie du code est une constante entière N de base 255, le reste est un décodeur de système numérique asymétrique , utilisant des probabilités codées en dur de 75% / 25% (la fréquence réelle de 0 est de 76,35%, ce qui est si proche de 75%). économiserait seulement 1,2 bits dans la charge utile, alors que les 75% permettent de sauver plusieurs octets dans le décodeur).
Voici l'encodeur ANS qui a généré la constante: Essayez-le en ligne!
la source
05AB1E ,
215210200 octetsEnregistrement de 15 octets grâce à Magic Octopus Urn
Essayez-le en ligne! ou avec formatage supplémentaire
Chaîne trinaire codée en base 255 avec les occurrences de
0000remplacé par2.la source
0000avec2par 9 autres octets. - pastebin.com/aZ6tHxjx pour 201Java,
688 678 590 379361 octetsRetourne une chaîne.
-10 octets en renvoyant le flux brut (ancienne réponse)
-88 octets en utilisant des valeurs numériques de base 10 (merci @ceilingcat!)
-211 octets (je savais que cela pouvait être joué au golf!) En utilisant un BigInteger codé en base 36 (merci @JollyJoker !)
-18 octets en utilisant un entier codé différent (merci encore @JollyJoker)
Essayez-le en ligne!
Explication:
la source
Gelée , 213 octets
Essayez-le en ligne!
J'ai joué avec le codage Huffman, mais les améliorations de la taille des données ont été compensées par le code supplémentaire. En tant que tel, il s’agit simplement d’une version encodée en base 250 de la sortie souhaitée. La sortie consiste en un entier qui, une fois décodé en tant que base bijective 2, donnera la liste 1D de 1 et 2. Merci @Emigna d'avoir signalé le changement de règles.
Essayez-le en ligne - avec un décodage supplémentaire pour démontrer la sortie!
Si un codage binaire plus conventionnel est préféré, en voici un qui code une représentation entière du message binaire inversé. Le bit le plus significatif de l'entier représente le début du message.
la source
Brainfuck,
236020081938 octetsEssayez-le en ligne!
Je vais probablement jouer au golf encore plus bientôt.
la source
Les poissons morts ~ ,
111510881084 octetsEssayez-le en ligne!
Si quelqu'un a la patience de jouer encore plus au golf, je vous salue d'avance. : P
-27 octets en imprimant des 10 et des 100 à des endroits appropriés.
-4 octets en imprimant trois 1000 et un 1001 sur la ligne 3
la source
Piet , 1763 codels
Génère un flux de 0 et de 1 (pas de saut de ligne).
Codel taille 1:
Codel taille 4, pour une meilleure visualisation:
Explication
Remarques
Le programme suit un chemin en spirale, dans le sens des aiguilles d'une montre, du haut vers la gauche jusqu'au centre. Les blocs noirs dispersés qui suivent grossièrement les diagonales constituent le contrôle de flux. Voici la trace de NPiet .
J'y travaille depuis le jour où le défi a été relevé, mais il a fallu un peu de temps pour que le message soit "écrit" dans la photo! J'ai d'abord écrit les boucles finales et la valeur sentinelle, puis j'ai construit le message du centre vers l'extérieur. (Comme Piet commence toujours l'exécution en haut à gauche, je m'attendais à devoir mélanger et faire pivoter l'image pour éviter les espaces blancs excessifs, mais elle correspondait parfaitement!)
Anecdote: Le codage par longueur dans Piet ne permet pas (par lui-même) d'économiser de l'espace. Il faut n codes de couleur pour appliquer la valeur n à la pile ou n codes de couleurs différentes pour insérer autant de 1 dans la pile. Donc, c'est le même nombre de codes dans les deux cas. Mais les grands nombres que RLE vous donne signifient que vous pouvez utiliser des astuces arithmétiques (par exemple, au lieu d’appuyer sur 9, vous pouvez appuyer sur 3, dupliquer et multiplier) pour réduire le nombre de codes et de blocs de forme amusante pour remplir les espaces disponibles.
Je ne savais pas trop comment compter le score des entrées de Piet. J'ai trouvé certains qui semblent compter tous les codes, et d'autres explicitement que ceux qui sont activement utilisés. Je viens de les compter tous; ignorer les codes blancs (même ceux que le programme ne traverse jamais) semble s'apparenter à ignorer les espaces dans un langage de programmation plus typique.
Oh, et tout à l'heure (deux heures après avoir posté), j'ai réalisé que j'avais perdu mon temps à travailler là-dessus. Je voulais couper la dernière ligne et la dernière colonne presque complètement blanches, alors j'ai remué tout ça… y compris les blocs noirs de contrôle du flux. Mais les bords de l'image fonctionnent comme le noir! Si je venais de m'en souvenir, je n'aurais pas eu besoin de passer autant de temps à déconner au sujet de la complexité des PDD et des CC ...
la source
C # (compilateur interactif Visual C #) ,
366332329319 octetsRemplacez toutes les instances de
␀with\0to test.Essayez-le en ligne!
C # (compilateur interactif Visual C #) , 305 octets, 210 caractères
Idem avec ci-dessus, remplacez par
␀par\0pour tester. Sortie en tant queIEnumerable<string>.Essayez-le en ligne! (Gracieuseté de Jo King)
la source
++in12-i++%2est un nop (du moins, cela a fonctionné pour moi lorsque je l'ai enlevé)Perl 6 , 368 octets
Essayez-le en ligne!
La longue chaîne est le message composé d'un seul nombre base-36 (avec un seul bit préfixé pour conserver les zéros non significatifs), qui est ensuite reconverti en binaire et imprimé 23 bits à la fois.
la source
>>.sayet&{S/.//}pour sauvegarder des octets. Avez-vous pensé à utiliser une base différente à la place?Wolfram Language (Mathematica) , 383 octets
Essayez-le en ligne!
la source
Node.js , 333 octets
Renvoie une chaîne binaire de 1 679 caractères.
Essayez-le en ligne! (avec sortie formatée)
JavaScript (ES8), 413 octets
Renvoie une chaîne binaire de 1 679 caractères.
Essayez-le en ligne! (avec sortie formatée)
la source
Bubblegum,
275236 octetsEssayez-le en ligne!
la source
outils bash + GNU, 351 octets
TIO
la source
MathGolf ,
223220 octetsEssayez-le en ligne!
Explication
la source
L/nvers le pied de page, donc c'est en fait 220 octets. Peut-on sauvegarder davantage d'octets en portant les réponses 05AB1E / Java (à l'aide de cet entier compressé , convertissez-le en base 3 et remplacez tout2s par0000s)?2à♫░╞? EDIT: Peu importe. Je vois que vous ne disposez pas d'une conversion de base intégrée (sauf binaire / hexadécimale) pour convertir en base 3?+au pied de pagePerl 5 , 460 octets
Essayez-le en ligne!
la source
Python 2 , 336 octets
Essayez-le en ligne!
Imprime une chaîne d'octets
la source
Java (OpenJDK 8) , 364 octets
Essayez-le en ligne!
Explication: D'abord
n->new java.math.BigInteger(str,36).toString(2), convertir simplement un nombre de base 36 en binaire, mais cela nécessitait neuf caractères supplémentaires pour les zéros non significatifs. Ensuite, j'ai eu l'idée de coder en longueur quelques zéros par longueur. Une longueur de quatre zéros semble minimiser la longueur de la base 36, doncn->new java.math.BigInteger(str,36).toString(3).replaceAll("2","0000")Voir la discussion sous cette réponse pour le correctif de zéros principaux de @KevinCruijssen
la source
[Python 2] , 345 octets
J'ai encodé la longueur des chaînes de 0 sous la forme d'un octet commençant à chr (31). Ensuite, j'ai encodé les 10101 restants sous forme de nombres binaires allant de chr (70) à chr (126). Les chaînes binaires qui ne correspondaient pas ont été scindées en morceaux plus petits.
Edit: réduit à 326 octets. Merci Jo King
Edit: Correction d'un bug dans le programme générateur de code
Edit: édition finale
la source
oune variable.Zsh , 577 octets
essayez-le en ligne !!
Utilisé la logique de codage personnalisé. La chaîne
Sest de 421 caractères, pourrait éventuellement être compressée un peu plus. Les lettresa-wreprésentent une répétition de l'0art. Les chiffres1-9représentent des répétitions de l'1art. Les lettresx y zreprésentent10 100 1000respectivement.J'aurais peut-être dû essayer l' encodage par paire d'octets ou Ascii85 .
la source
Frapper ,
702697 octetsEssayez-le en ligne!
la source
Rubis , 362 octets
Entier écrit en base 36. Il existe sûrement un moyen plus efficace de compresser l'entier, par exemple avec
zliboubase64.Essayez-le en ligne!
la source
[C ++ (VC ++) (mais également testé avec gcc)], 585 octets
Essayez-le en ligne!
Version non-golfée (manque la pause après le 1679ème élément et va jusqu'au 1680ème):
en tant qu'explication: j'ai concaténé les 73 lignes de sortie d'échantillon données en une seule ligne longue. Je les ai codés en hexadécimal où l’ordre des bits est msbfirst (en utilisant ce programme https://github.com/Marc-Bender/longBinaryStreamToHex/releases/download/addedErrorCode-4/longBinaryStreamToHex.exe ) j’ai raccourci la sortie de celui-ci par environ 70 chiffres hexadécimaux en utilisant les lettres 'G' - 'Z' comme signe pour répéter le dernier chiffre une certaine quantité de temps (Z = 2 fois, Y = 3 fois plus…) le reste devrait être relativement explicite pour les golfeurs . abuser du préprocesseur pour raccourcir les boucles, abuser de l'
,opérateur, etc.Le format de sortie est un flux ininterrompu de 1679 valeurs 0/1.
la source
Perl 6 , 348 octets
Basé sur la solution Java de Benjamin Urquhart .
Utilise un flux direct de 0 et 1 caractères. Le lien ci-dessous contient du code pour épurer la sortie.
Essayez-le en ligne!
la source
Tcl , 366 octets
Essayez-le en ligne!
la source
C ++ (avec la bibliothèque multi-précision Gnu), 359 octets
Ceci sort la chaîne comme une ligne. Il utilise '1' pour 0 et '0' pour 1: /
Il lit simplement la chaîne incorporée en base 62 et l’imprime en base 2.
Utiliser
g++ -g arecibo.cpp -lgmp -lgmpxxpour compiler et lierla source
class_mpzparmpz_classPerl 6 , 276 octets
Essayez-le en ligne!
Les sorties sont une série de 1679 0 et 1. Vous pouvez l'avoir sur différentes lignes en ajoutant
.comb(23)>>avant lesay.Explication:
Je peux probablement économiser des octets en utilisant la sortie sous la forme d'un entier de 1679 bits ou en inversant la représentation des bits.
la source
C ++ (gcc) , 748 octets
Essayez-le en ligne!
En remplaçant la sous-chaîne la plus utilisée par un nouveau caractère jusqu'à ce que cela n'en vaut plus la peine
la source
Python 3 , 331 octets
Essayez-le en ligne!
la source