Invia il messaggio Arecibo


38

Il messaggio di Arecibo è un messaggio radio interstellare del 1974 che trasportava informazioni di base sull'umanità e sulla Terra inviate all'ammasso stellare globulare M13 nella speranza che l'intelligenza extraterrestre potesse riceverlo e decifrarlo ... Il messaggio consisteva in 1.679 cifre binarie, circa 210 byte ...

Il numero 1.679 è stato scelto perché è un semiprime (il prodotto di due numeri primi), che deve essere disposto in modo rettangolare come 73 righe per 23 colonne. La disposizione alternativa, 23 righe per 73 colonne, produce un insieme incomprensibile di caratteri (come tutti gli altri formati X / Y).

Il messaggio di Arecibo

Questo è il messaggio con il colore aggiunto per evidenziare le sue parti separate. L'attuale trasmissione binaria non portava informazioni sul colore.

Fonte: Wikipedia


Il tuo compito è quello di produrre il messaggio Arecibo nella disposizione esatta 23x73 mostrata nell'immagine. Uno di questi formati di output è accettabile:

  • Testo, usando un carattere per uno e un altro per zeri (usando le solite regole per la separazione delle righe)
  • Un array 2D di due valori distinti
  • Un'immagine 23x73 con due colori distinti
  • Un flusso ininterrotto di 1679 elementi con due valori distinti (ovvero uno dei formati sopra indicati, ma piatto).
  • Un numero intero a 1679 bit. Indica l'ordine di bit e byte (endianness) nella tua soluzione.

Per comodità, ecco una versione copia-pastable (anche un esempio di output in formato testo):

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

Se la tua lingua, per qualche motivo, ha un built-in per il messaggio Arecibo, non puoi usarlo.

In bocca al lupo!

AGGIORNAMENTO: ho accettato la risposta 05AB1E poiché era la prima ad essere più breve del messaggio originale. Non lasciarti dissuadere da nuove soluzioni.

AGGIORNAMENTO 2019-09-09: la risposta accettata è stata spostata in una nuova risposta 05AB1E, poiché oscura la precedente risposta 05AB1E. Lo stesso punto vale per l'aggiornamento precedente; nuove soluzioni sono ancora ben accette.


9
Se una lingua ha un messaggio incorporato per Arecibo, posso dire, con tutta certezza, che ho visto tutto in questo mondo c:
Luis felipe De jesus Munoz

6
Mathematica (IIRC) ha un'immagine incorporata per Lena, quindi non mi sorprenderebbe se avesse anche un messaggio Aricebo.
Beefster

@RobertS. no perché ci sono altri formati validi oltre al testo.
Beefster

4
Nello spirito del formato originale, dovrebbe essere consentito un risultato / output piatto. L'intero punto di 1679 bit è esattamente che il numero corretto di righe e colonne può essere dedotto dalla lunghezza del segnale.
Adám,

4
@LuisfelipeDejesusMunoz Mathematica ha un builtin per determinare le capre in una foto , quindi un messaggio di Arecibo incorporato non mi sorprenderebbe nemmeno .. Quel linguaggio è costruito su builtins dell'universo ..>.>
Kevin Cruijssen

Risposte:


2

05AB1E , 182 byte

•sv¯ö¨₁ÿ.ÛïžôΔ¨γ_Ígv…=Bм„Ð.(ܦi´…ε±G½0^/₃öRÛž¼¤"āêL!ˆ6‘Gā܇ðв₁÷Ã7€₂䬂Cć¨g¾†@÷[_-68¯a∍iG*6ÆîÆ;>éjζãÎÂ+ºžnî¼ć'(ÝÞΔ‹∞ÉݹÕ5λ₆*a|§oÄmôæ¨;—:hž¥ð¢ocË'¨%¡4Ćáß©ìća;FÁ?iˆèεƒʒ•Ž6–FD4‰`3ÊD?i-

Provalo online! (utilizza 1per 0 e 0per 1, come consentito dalla domanda).

Provalo online! (5 byte in più, 0per 0 e 1per 1, aggiunte nuove righe per la leggibilità).

La maggior parte del codice è una costante intera N base-255, il resto è un decodificatore del sistema numerico asimmetrico , utilizzando probabilità codificate al 75% / 25% (la frequenza effettiva di 0 è del 76,35%, che è così vicina al 75% che risparmierebbe solo 1,2 bit nel payload, mentre il piacevole e rotondo 75% ci consente di salvare diversi byte nel decodificatore).

Ž6–F                  # repeat the following 1679 times:
    D                 #  duplicate N
     4‰`              #  divmod 4: pushes N / 4, N % 4 on the stack
        3Ê            #  is N % 4 != 3 ? (boolean 1 or 0)
          D?          #  print a copy
            i-        #  if it's 1, subtract: N = N - (N / 4)
                      #  (otherwise, N = N / 4, since that's the top of the stack)

Ecco l'encoder ANS che ha generato la costante: provalo online!

Î                          # start from N = 0
 Rv         ]              # for each bit in the reversed input:
   4*                      #  N *= 4
     yi                    #  if the bit is 1:
       3+                  #   N += 3
         ë                 #  else:
          3÷               #   N /= 3 (integer division)
             ₅B'•.ø        # compress N as base-255

Ottimo lavoro per obsoleto la precedente risposta 05AB1E!
Beefster,

13

05AB1E , 215 210 200 byte

Salvato 15 byte grazie a Magic Octopus Urn

•cOž¤4é57ñΛ\Ö₃BαöĀíL½₅üBdoÙRθLγ¨G×Tćú$G(˜ƒ¦!€R»SDrµCnJ†d∊ζ·<8‡T@|‹ï=BζćósxG\ÙÎ$¿o₁5/ÔŸÇBûXé-”a::Ž]°∊y;ζ]MÜβ‘иL”β{üÃÇíäc€÷›ÎU=}¨иaŸdY`»¾ÚUβ:ô©¦β†₅DGŠβ3Jêθ,äá!ícqšVÖ›lÈΣ¯pε €êʃDpÙ/¬Žλ8:ãÿ3=€.Þć•3BY¾4×:

Provalo online! o con formattazione aggiuntiva

Stringa trinaria codificata Base-255 con occorrenze 0000sostituite da 2.


@MagicOctopusUrn: grazie! Questo rende 210 persino :)
Emigna il

In realtà è ancora meglio se lo sostituisci 0000con 2altri 9 byte. - pastebin.com/aZ6tHxjx per 201
Magic Octopus Urn

@MagicOctopusUrn: Sì, l'ho scoperto anch'io e stavo per pubblicarlo :)
Emigna,

2
Freddo! Poiché i messaggi di Arecibo sono 210 byte (23 * 73/8 = 209.875), la tua soluzione (attualmente a 200 byte) è più breve del messaggio stesso!
JL

Sono andato avanti e ho reso questa la risposta accettata poiché era la prima ad essere più breve del messaggio stesso.
Beefster,

11

Java, 688 678 590 379 361 byte

Restituisce una stringa.

n->new java.math.BigInteger("in95mzupnpa2r0khpoepyql6ioqyn413avucdtfay6indx4wh9dehe3sn18klobtf4z9g9q17umqmwpegr2khb5eqinn7azl4jpfp2a8eui0xfrx5qwrou6gd65jh4ge3ls14k5lu7qrvmg6942ms29u5rb8fa6yrdhfoh5zoi9bdi7uh5ig0u0ff9kounth8sh357x7qox4m3oqviqsbrvakonbka4ahp21bgzi5v1akzzuqoncszhpabbru9q1uo2g11zr73iuyiqr5ikr69zn7cdv7e1lhd6ese9",36).toString(3).replace("2","0000")

-10 byte restituendo il flusso non
elaborato (vecchia risposta) -88 byte utilizzando i valori numerici di base 10 (grazie @ceilingcat!)
-211 byte (sapevo che poteva essere giocato a golf!) Utilizzando un BigInteger codificato in base 36 (grazie a @JollyJoker !)
-18 byte utilizzando un numero intero codificato diverso (grazie ancora @JollyJoker)

Provalo online!

Spiegazione:

n->new java.math.BigInteger("base36 string",36) // Decode the base-36 integer.
   .toString(3)                                 // Re-encode as ternary
   .replace("2","0000")                         // Replace 2 with "0000"
                                                // Implicit return

1
I commenti non sono per una discussione estesa; questa conversazione è stata spostata in chat .
Adam Lear

9

Gelatina , 213 byte

“H²ɓ¶Ṡḷ€ẹ]ƒf*ḳḢ&ƁṇOḥ{ḄṫwỊ+oLạʋߢH9¢¹÷ỴɗÇ⁶ƲƙæḊẋ3³=1!VƇƁ'D⁺3Ỵɱ©⁵%fȯez#ƈjƒżṆo.ZF⁶ċṢ⁶ọṛb9Ȯƒd?ƁUĠt4ẇ,ḞġƒµƭfʠƁP§÷øȤŻPɲẋ(¢ß¢(⁽3¶ṙėɗy@ṁYȮL~e⁷ƤĊ§nỊṅµṠ°@7ẠB>Ġ⁻İ}uy¡½:esOpḢt}qS©HÞṬĖṛṇḣ9÷;ESḢ,Ẉ^ṙpƲ©tṃwçnẒṆ¡⁻Jıƒị£-&Ɱ*ẋʂżoȯÑḢɼ’

Provalo online!

Ho giocato con la codifica Huffman, ma i miglioramenti nella dimensione dei dati sono stati compensati dal codice aggiuntivo. Come tale, questa è semplicemente una versione codificata in base 250 dell'output desiderato. L'output è costituito da un numero intero che una volta decodificato come base biiettiva 2 produrrà l'elenco 1D di 1 e 2 secondi. Grazie @Emigna per aver segnalato il cambiamento nelle regole.

Provalo online - con ulteriore decodifica per dimostrare l'output!

Se si preferisce una codifica binaria più convenzionale, eccone una che codifica una rappresentazione intera del messaggio binario invertito. Il bit più significativo dell'intero rappresenta l'inizio del messaggio.


7

Brainfuck, 2360 2008 1938 byte

-[>+<-----]>---......+.-.+.-.+.-.+.-............+.-.+.-.....+.-.+.-.......+.-.<++++[->.+.-..<]>+.-.+..-.<+++++++++[->.+.-<]>..+.-..+.-<++++++[->......<]>.+.<++[->.-...................+..-.+<]>.-..................+.-.+.-.+.-..................+.....-<++++++++[->....<]>+..-....+...-...+..-....+..-...+.-.............+..-..+.-....+..-.+.-...+..-...+..-....+..-.+<++++[->.-.+....<]>.-<+++++[->.....<]>.+.-.................+.-............................+.-.................+......-.............+.....-.......................+..-....+..-....+...-...+..-...+.-.......+.-.........+.-....+..-.+.-....+..-...+...-..+..-.+.-.+.....-.+.....-.+.....-.+.....-..........................+.-......+..-.........+.-...........+..-...............+.-.....+..-..........+......-.....+..-......+.....-..........+..-.....<+++[->........+.-<]>.....+.-......+..-.......+.-.......+..-....+..-......+.-..........+..-...+.-....+..-...............+..-..+..-.............+..-...+.-....+..-.........+..-....+..-......+.-.......+.-......+.-........+.-.....+.-<++[->.......+..-........+.-...+.-.<]>........+.-.......+.-<++++[->.....+.-..<]>..........+..-.........+..-........+..-.........+.-...+...-.+.-.+..-...........+.-.......+.-..............+.-.....+.....-............+.-....+.-.+...-.+.-..+.-.+..-.+..-......+.-..+...-..+.-..+.......-.+...-....+...-.....+..-.+...-.........+.-.+.-.....+...-.+..-..+.-......+.-.+.-.....+......-..+.-......+.-.+.-.....+..-......+.-.....+..-.+..-<+++++++[->.....<]>+...-.....+.-..............+...-.+.-.+.-..<++++++[->.+.-<]>..+...-.........+.-.+.-.+.-.+.-................+.-.+.-..............+.....-................+.........-............+...-.......+...-.<++[->........+..-...<]>....+..-.+.-.........+.-.+..-<++[->.....+..-..+..-..<]>..+.-...+.-.+.-.....+.-.+.-...+.-..<+++[->..+.-...+.-<]>........+.-...+.-.+.-...+.-............+.-....+.-.<++[->...+.-.........<]>+.-..............+.-..+.-.+.-...........+....-..+.....-.+.-..+....-...

Provalo online!

Probabilmente lo farò ancora più presto.


5

Pesce morto ~ , 1115 1088 1084 byte

oooooo{i}ooo{d}iod{o}{i}c{d}ooiodoiodoooooiodoiodoooooooiodoo{i}c{ii}is{iiii}doooio{{{d}}}oioodooiodo{i}coooooooo{d}o{{i}}oo{{d}i}c{d}{oo}ooo{i}c{d}{o}ooioodooooooooo{i}c{d}{o}ioodoiodooooooooo{i}c{d}{o}ioodoiodooooooooo{i}c{d}oooooooooiodoiodoiodooooooooo{i}c{d}oooooooooiooooodooooooooo{i}c{d}{oo}ooo{i}c{d}ioodooooiooodoooioodooooioodooo{i}c{d}iod{o}oooioodooiodoooo{i}c{d}ioodoiodoooioodoooioodooooioodoiodo{i}c{d}iooooodoiooooodoiooooodoioooood{i}c{d}{oo}ooo{i}c{d}oooiod{o}oooooooiodo{i}c{d}{oo}ooo{i}c{d}ooooiod{o}oooooooiod{i}c{d}ioooood{o}oooioooood{i}c{d}{oo}ooo{i}c{d}ioodooooioodooooiooodoooioodooo{i}c{d}iodoooooooiodoooooooooiodoooo{i}c{d}ioodoiodooooioodoooiooodooioodoiodo{i}c{d}iooooodoiooooodoiooooodoioooood{i}c{d}{oo}ooo{i}c{d}oooiodooooooioodoooooooooiodo{i}c{d}{o}iood{o}o{i}c{d}ooooiodoooooiood{o}iod{i}c{d}iooooodoooooioodooooooioooood{i}c{d}{o}iood{o}o{i}c{d}ooiodooooooooiodooooooooiodoo{i}c{d}oooiodooooooioodoooooooiodooo{i}c{d}ooooioodooooioodooooooiodoooo{i}c{d}ooooooioodoooiodooooioodooooo{i}c{d}{o}ioodooioodooooooo{i}c{d}ooooooioodoooiodooooioodooooo

Provalo online!

Se qualcuno ha la pazienza di giocare a golf così ulteriormente, ti saluto in anticipo. : P

-27 byte stampando 10s e 100s nei punti dove applicabile.
-4 byte stampando tre 1000 e un 1001 sulla riga 3


4

Piet , 1763 codici

Emette un flusso di 0 e 1 (nessuna interruzione di riga).

Dimensione del codice 1:

Arecibo message program with codel size 1

Dimensione del codice 4, per una visualizzazione più semplice:

Arecibo message program with codel size 4

Spiegazione

  • Innanzitutto, inserisci un valore sentinella di -1 nello stack.
  • Quindi spingere il messaggio Arecibo, in ordine inverso (perché è uno stack), utilizzando la codifica di lunghezza di esecuzione.
  • Infine, alternare tra due anelli, uno zero di stampa e l'altro di stampa.
    • Il contatore di loop è il valore di stack corrente, decrementato fino a raggiungere zero, a quel punto viene scartato e passiamo all'altro loop.
    • Tra il ciclo zero e il ciclo one, controlla il valore sentinella, uscendo se viene trovato.

Gli appunti

Il programma segue un percorso a spirale, in senso orario da sinistra in alto al centro. I blocchi neri sparsi che seguono approssimativamente le diagonali sono il controllo del flusso. Ecco la traccia di NPiet .

Ci sto lavorando dal giorno in cui è stata lanciata questa sfida, ma ci è voluto un po 'di tempo per far "scrivere" il messaggio nella foto! Ho scritto prima i loop finali e il valore della sentinella, quindi ho creato il messaggio dal centro verso l'esterno. (Poiché Piet inizia sempre l'esecuzione dall'angolo in alto a sinistra, mi aspettavo di dover mescolare e ruotare l'immagine per evitare spazi bianchi in eccesso, ma si adatta perfettamente!)

Curiosità: la codifica run-length in Piet non (di per sé) non risparmia spazio. Ci vogliono n codici di un colore per spingere il valore n nella pila, o n codici di colori diversi per spingere quel numero di 1 nella pila. Quindi è lo stesso numero di codici in entrambi i modi. Ma i numeri più grandi che ti dà RLE significano che puoi usare trucchi aritmetici (ad esempio invece di spingere 9, puoi spingere 3, duplicare e moltiplicare) per ridurre il numero di codici e blocchi a forma di divertente per riempire gli spazi bianchi disponibili.

Non ero sicuro di come contare il punteggio per le voci Piet. Ho trovato alcuni che sembrano contare tutti i codici, e altri che contano esplicitamente solo quelli usati attivamente. Li ho appena contati tutti; ignorare i codici bianchi (anche quelli che il programma non passa mai) sembra simile a ignorare gli spazi bianchi in un linguaggio di programmazione più tipico.

Oh, e proprio ora (due ore dopo la pubblicazione) ho capito che ho perso l'ultimo po 'di tempo a lavorare su questo. Volevo tagliare l'ultima riga e colonna quasi completamente bianche, quindi ho mescolato le cose ... compresi i blocchi di controllo del flusso neri. Ma i bordi dell'immagine funzionano allo stesso modo del nero! Se me lo fossi appena ricordato, non avrei dovuto passare così tanto tempo a scervellarmi sulle complessità di DP e CC ...


3

C # (compilatore interattivo Visual C #) , 366 332 329 319 byte

int i;foreach(var g in"*ЀʂЄ࢈ҲપԤ␀␀␀؀ȀȀȀ؀␀␀సؘࠀƐഘؚ྾ߟ␀␀Ā␀␀ྀ␀␀రܘࠈഌΚ྾ߟ␀␀ă␀ྃ␀ȁăÃ1`ƀ1`ÃĂȃЃЁȂĀ`ÀƀȺ؀Ȃ␀ȏЀȗɛ'Ŀஇ7;ȅ?ȅ0ȍЀ␀␀΂␀ΨՕ΀Ŕ␀ŀЀ?܀àǀƀ`̀°٠Ƙѐʈш҈EB@Ѐޟɸ")Write(Convert.ToString(g,2).PadLeft(12-i++%2,'0'));

Sostituisci tutte le istanze di con \0per testare.

Provalo online!

C # (compilatore interattivo Visual C #) , 305 byte, 210 caratteri

_=>"*ЀʂЄ࢈ҲપԤ␀␀␀؀ȀȀȀ؀␀␀సؘࠀƐഘؚ྾ߟ␀␀Ā␀␀ྀ␀␀రܘࠈഌΚ྾ߟ␀␀ă␀ྃ␀ȁăÃ1`ƀ1`ÃĂȃЃЁȂĀ`ÀƀȺ؀Ȃ␀ȏЀȗɛ'Ŀஇ7;ȅ?ȅ0ȍЀ␀␀΂␀ΨՕ΀Ŕ␀ŀЀ?܀àǀƀ`̀°٠Ƙѐʈш҈EB@Ѐޟɸ".Select((g,i)=>Convert.ToString(g,2).PadLeft(12-i%2,'0'))

Lo stesso con sopra, sostituire con con \0per testare. Uscita come IEnumerable<string>.

Provalo online! (Per gentile concessione di Jo King)



Credo che ++in 12-i++%2sia un nop (almeno, ha funzionato per me quando l'ho rimosso)
mio pronome è monicareinstate il

@someone Sono una copia-incolla della vecchia risposta che ho dimenticato di rimuovere
Embodiment of Ignorance

2

Perl 6 , 368 byte

.say for :36('FJXOE0PDDNF5Y5EHGB8M9SWMXQOXIKIT9F6ZKWWDEACHCBGXL1N2H60CN0CJ4EMKF7D6MODSKYJVNR4SFTDR6NSM421LQ67B6MWF0G5BQATFOJJJBQ0UFQM64T0MWSQN41C4S5D1QR5KJM2L9UTYMMKUBBQWY45YCMRGO8ZRGTQH7LXMZBUASLCTKX30IH0AYKYEPHO8HFHX8GAY5WM38YOSUX0HABYSH2PPBLRDRZIN5ANAQ3V8PLOZ6EHC0UI95EVJVYD1820T6J14HGX85NWFQET2NWOMSNUT0JW4LHMY90X094TEE9KXJXSNN6YPERFQW').base(2).substr(1).comb(23)

Provalo online!

La stringa lunga è il messaggio come un singolo numero base-36 (con un singolo prefisso 1 bit per preservare gli zeri iniziali) che viene quindi riconvertito in binario e stampato 23 bit alla volta.


È possibile utilizzare >>.saye &{S/.//}per salvare byte. Hai pensato invece di utilizzare una base diversa?
Jo King,

Sì, ho provato a utilizzare la base 65536 / Unicode, ma il messaggio si imbatte in alcuni punti di codice surrogati proibiti. Sono stato in grado di evitarlo aggiungendo un offset fisso a ciascun punto di codice, ma sorprendentemente, alcune delle stringhe generate hanno provocato il crash di Emacs alcune volte. La risoluzione dei problemi ha iniziato a richiedere più tempo di quanto potessi permettermi. Probabilmente rivisiterò il problema più tardi.
Sean,

Non ha senso entrare in più caratteri byte, poiché ciò aumenta il conteggio dei byte. 289 byte implementando i miei suggerimenti dall'alto e usando la base 122 (per evitare i ritorni
Jo King

2

Wolfram Language (Mathematica) , 383 byte

StringPartition[Uncompress@"1:eJylVNsRwjAM44s92KBaBTZgAUZhZXqtHUuOWrgjfSRRHFlO4tyer/vjfb1clq0gHirZLRjby986hppcT5p+L3BmgJ3t4Ul4GsNyG++7YbaXLh0ZTPhXa4Sn+X/s9Qfk3Hx2cOaSIuNYaVu5laschvgzSqAjHeZBhilKgKBDEhw0upJRg+HOK4MyNC29sfbc3RV0VPDqeLiRTsG1ulExq1IitpunOa7asnYM9siDZ6eidUCkEzBOUbCkGIig4aTyUGBYWAX6W6aXIWGGI/HlhmsqzSU0QTZjkMVpaX5sBsm1OGKVg1qdjKP0EdyqZBRLhukn8DLBQav6kccgz8OKfgBzjj6Z",23]

Provalo online!


2

Node.js , 333 byte

Restituisce una stringa binaria di 1.679 caratteri.

_=>Buffer(")SI)=.);1K?>>>2333A3,93/I3>3)g33)AEAAI)5JQZJTddda3)*3*33+3,e)*e3)//0/1+)1C/7Cgggg3395)9)A3IY)h*IH),39+)995*)AA-)59Y)*O3Z,)//*)91**)A*-)Y+1)I11+)I1)/)5)Y*0?)+)I)-0Y)1@;_*7<gaE/a)Q7[*9HM+IY16I33)a1)*^.><I+S3.38I)*hY)7)a)Y)A,9*A5Y/A:9=9K:1I-=9)19I)9*329)GH<").map(x=>s+=(x-51&&x-41).toString(2).padStart(x-51?6:12,0),s='')&&s

Provalo online! (con output formattato)


JavaScript (ES8), 413 byte

Restituisce una stringa binaria di 1.679 caratteri.

_=>atob('AsKoAFBQEiIlwpVVUk!!ABwo!DQ!Gg!V!Aw7g!!GHGHCi!yGjHChsK+w7vDr8K!!Q!Q!!g!/DgAHDs!AGGHDhiAgCGhjwprDu8Ovwr4!ABAw4AQAcK!MKDAD8GB8OAD!QCAQQMBAYYEAMQwABwpgAMQwBwoYEBAgEEBgEQDAIwoAgIMKAwoDCgMKABgDDgDAEdcKACAgAEHwAIXTCtgTDpMO+w6HDgcK4AsKDwrIFB8OkCgwINg!!A4IAB1FVTDoArCo!U!/CgAB/w4ADwoDDoAwAYDQBYMOMBmEUFEIkSMKARR!woQgAQB!MKUAHnDtA'.split`!`.join`AA`).replace(/[\s\S]/g,c=>c.charCodeAt().toString(2).padStart(8,0))

Provalo online! (con output formattato)


2

Bubblegum, 275 236 byte

00000000: e006 8e00 e45d 0018 6988 6507 a228 f86f  .....]..i.e..(.o
00000010: f042 c62f d4d7 b99e 38bc 56c4 52e8 2630  .B./....8.V.R.&0
00000020: 8aaa 7252 d47d 5ef4 c96a 511f 6842 423f  ..rR.}^..jQ.hBB?
00000030: 4532 ca9f 22d3 1633 e0c4 665a d5dc 4e68  E2.."..3..fZ..Nh
00000040: 7b09 76ae 3c7e f9d4 fa4a 05e0 4163 c580  {.v.<~...J..Ac..
00000050: c585 a383 2396 4ca9 1f48 a4b9 744e 37c8  ....#.L..H..tN7.
00000060: 68c5 af23 645d 59a7 542a e6d1 23b9 3aba  h..#d]Y.T*..#.:.
00000070: f0e6 2738 dfd5 b0a3 c6a3 60bf c5b6 5ae6  ..'8......`...Z.
00000080: 7893 30a8 ae04 edf9 298b b777 4d56 285b  x.0.....)..wMV([
00000090: cb74 07cc 7a7b a399 3dc7 c6e7 b693 e715  .t..z{..=.......
000000a0: d908 876e 001f 7408 3c6a 5fcd 37cb 02c4  ...n..t.<j_.7...
000000b0: 93de 33c2 a11e 5bac cd12 d99a fac3 e0fa  ..3...[.........
000000c0: 5268 94f7 d640 0f73 cede f79d 821f 39d1  Rh...@.s......9.
000000d0: dc49 ff06 6962 6c31 dc29 a077 01c3 7690  .I..ibl1.).w..v.
000000e0: 85ef bbec 31d7 5c7f f9fc 8c00            ....1.\.....

Provalo online!


2

bash + strumenti GNU, 351 byte

base64 -d<<<H4sIAPnNrVwCA6WUCRLDIAwDv8T+/3NNG4wvkTBTcisGSyA8xrcxj9Ds02F+Z7yuf3hnPyz0vYEGz+FG3IKBs+x3oL2PSh0TM/PnaGamft9nPUCew3uCp5RBWdRKGz+qNJn8qRKkkNaTBgeVIFXWOdi8VCaIeUnsfHo6TXpaFa3H5olf6J5MuIHLoEi0uKcRFCvEXG4xseglKzZg7kpYJSLMA3M7wXKR+/L2WiK0kvg+TDASLp6Co1KEVIlVmFzhCktRhBBDdSZYU1xKHrmDUllcWpNR/YNW2QNcHtF0rSySb0MXk/SDUgEwG5gfLvQDxuEdDo8GAAA=|gunzip

TIO


non ho visto il tuo post bash prima che io pubblicassi il mio - molto più piccolo!
Noodle9

2

MathGolf , 223 220 byte

'06*"x·<×J× Ç×►B×ê\"@$↕!◙è0♥f░×→0×♠p└☺α?×└•×◙×P♣p¬è:×►∟××××←♦♠♣≥â☻┘A☺▄αp⌂r☻[║►×>◘×♦♦└:☻↑`×♥@@@@►►@♦↑ ☻♀◘☻♦☻☻├×å↑×╠×Ç!♠ 0♀◘↑◘☻♦◘×♠α♥â▼ÇA×└×◘` ×××▀≈}═14♦►►π0♀××°×α•×►×××☻×◘××└≈}_├↑♪↓×─0♫♥×××|××*××♪×Ç♠×└×××× ⌐¬╩↕◄○((×T☺"$à+

Provalo online!

Spiegazione

'0                push single character "0"
  6*              repeat 6 times
    "..."         push the magic string
         $        convert to ordinal
          à       convert to binary string
           +      pop a, b : push(a+b) (add the 6 zeroes)
                  below is the footer
            L/    divide into groups of 23 characters
              n   join array with newlines into string

Puoi spostare il L/npiè di pagina, quindi in realtà è di 220 byte. È possibile salvare più byte eseguendo il porting delle risposte 05AB1E / Java (utilizzando questo intero compresso , convertirlo in base-3 e sostituire tutti 2i messaggi di posta elettronica con 0000s)?
Kevin Cruijssen,

@KevinCruijssen bella cattura! Vorrei avere più funzioni di sostituzione delle stringhe, ma al momento non fa parte di MathGolf.
max

Che ne dici di una mappa per cifra, quali mappe 2 a♫░╞ ? EDIT: Non importa. Vedo che non hai incorporato una conversione di base (tranne binario / esadecimale) da convertire in base-3?
Kevin Cruijssen,

@KevinCruijssen Ho pensato un po 'a come dovrei cambiare la conversione di base. Certamente non ho bisogno di un comando per convertire la stringa binaria in decimale e un altro per convertire un array binario in decimale. In questo modo, posso inserire un altro comando di conversione di base (e l'idea è sempre stata quella di avere una conversione di base generale nella lingua).
max

Sicuramente puoi anche spostare il +piè di pagina
Jo King il

1

Perl 5 , 460 byte

printf"%023b",oct"0x$_"for qw/15400 141404 4444b2 555524 0 600 1a00 1a00 2a00 3e00 0 61c618 400190 68c61a 7df7df 0 80002 0 40001 7c001f 0 618718 404010 68639a 7df7df 0 81802 1800 41801 7c181f 1800 100804 81808 61810 18860 1980 18860 61810 81008 101804 201804 200808 101010 80060 60180 11d600 101000 107c00 10ba5b 1393f 5c3837 283b 10283f 102830 106c00 0 1c1000 1d4555 1c0154 140 7c00 1ff00 701c0 c0060 1a00b0 330198 228288 224488 22880 21080 20080 9400 3cfa78/

Provalo online!


1

Python 2 , 336 byte

print bin(int('gVQAKCgJERLKqqkgAAAAAMAABoAADQAAKgAAfAAAAAMOMMQAGQ0Yw19998AAAAgAAgAAABAAB+AA+AAADDDjEBAENDHNffffAAAAIGAIAMAAQYAfgwPgBgAIBAIIGAgMMCAGIYAAzAAYhgDDAgIEAggMAiAYBEAQEEBAQEADAGAYAjrABAQACD4AELpbAnJ/cODcAUHZAoPyBQYEGwAAAAAcEAA6iqpwBVAACgAHwAA/4AHAcAYAMBoAsGYDMIoKIRIkQCKIAEIQAIAgAEoAPPp4'.decode('base64').encode('hex'),16))[3:]

Provalo online!

Stampa una stringa di byte


1

Java (OpenJDK 8) , 364 byte

n->new java.math.BigInteger("in95mzupnpa2r0khpoepyql6ioqyn413avucdtfay6indx4wh9dehe3sn18klobtf4z9g9q17umqmwpegr2khb5eqinn7azl4jpfp2a8eui0xfrx5qwrou6gd65jh4ge3ls14k5lu7qrvmg6942ms29u5rb8fa6yrdhfoh5zoi9bdi7uh5ig0u0ff9kounth8sh357x7qox4m3oqviqsbrvakonbka4ahp21bgzi5v1akzzuqoncszhpabbru9q1uo2g11zr73iuyiqr5ikr69zn7cdv7e1lhd6ese9",36).toString(3).replaceAll("2","0000")

Provalo online!

Spiegazione: Prima avuto n->new java.math.BigInteger(str,36).toString(2) , sufficiente convertire un numero di radix 36 in binario, ma ciò necessitava di nove caratteri aggiuntivi per gli zeri iniziali. Quindi, mi è venuta l'idea di codificare in lunghezza di alcuni zero come due. Una lunghezza di quattro zeri sembra minimizzare la lunghezza della radice 36, quindin->new java.math.BigInteger(str,36).toString(3).replaceAll("2","0000")

Vedi la discussione sotto questa risposta per la correzione di bug di zero iniziali di @KevinCruijssen


Bello. È incredibilmente breve per Java!
Eric Duminil,

1

[Python 2] , 345 byte

s=''
for c in")pG/K(K*j$h%kk$ppjGE&I6S6S5[5eCv~vw0x&z$wgqcde$e=G4G?G4eG0e:vv~w*G,gn$wy$uuuuG=G)I,G.I2G(I-eG(I)e-I0G+G+G(G)I*G*vI)G-w'I2y0w'I,vI)G*G)G+G(G*I+W+I+W,G*G(G*G*G*G/I,I+I,iq.G*G1G(e/g$c%sG)m%md~$M(},K(cO)K(eO)K(I)G(aE$M(G1c$hpoI,pG3K1e3eU/M*M,I.I*S,Q(y*y'hG(ng&j$j$G+hW/g'G/G,G1k.d$e$mN":c=ord(c)-35;s+=[bin(c-35)[2:],'0'*c][c<35]
print s

Ho codificato la lunghezza delle stringhe di 0 come byte a partire da chr (31). Quindi ho codificato il restante 10101 come numeri binari a partire da chr (70) fino a chr (126). Le stringhe binarie che non si adattavano venivano suddivise in blocchi più piccoli.

Modifica: ridotto a 326 byte. Grazie Jo King

Modifica: risolto un bug nel programma generatore di codice

Modifica: Modifica finale


Non è necessario salvare la stringa grande in ouna variabile.
xnor

1

Zsh , 577 byte

provalo online !!

S=fxxxxibxxdxxfyzzzyx1yxxxxxxxxyyywl2ij1xxhj1xxhixxxhi5iw2d3c2d2cxl2bxc2az2c2d2ax4x4x4x5wcxpxwdxp15m5w2d2d3c2cxfxhxc1xxc2c2y1xx4x4x4x5wc1f2ixj2kd1e2j15e2f5j2kb1h1hyc1f2gzd2d2fzaf2c1d2ej2b2gf2c1d2ed2d2f1dc1f1hzb1g2hya1h2hya1i1gzb1g1g1dc1l2ed2h2gbz2xx2ibzd1lbzb5jb1dx2xyx1x2fy2yy6x3d3e2a3ixxd2x2b1fxxd6b1fxxd2db1e2a2jwb3e1lb2xxzxxxxx1b3ixxxynxxeh5jf9hd3g3fc2k2eb2a1ix2da2b2g2b2cazxxdxzzazyzyzzezxz1ge1d1d1ge1i1ggyxxia3y4xy3z
for X in ${(s::)S};{case $X in
[a-w])V=$[##$X-96];printf 0%.s {1..$V};;[1-9])V=$[##$X-48];printf 1%.s {1..$V};;[x-z])V=$[##$X-119];printf $[10**$V];;esac}

Logica di codifica personalizzata utilizzata. La stringa ha S421 caratteri, potrebbe essere compressa un po 'di più. Le lettere a-wrappresentano ripetute 0s. I numeri 1-9rappresentano ripetuti 1s. Le lettere x y zrappresentano 10 100 1000rispettivamente.

Forse avrei dovuto provare la codifica a coppie di byte o Ascii85 .


0

Bash , 702 697 byte

xxd -r -p<<X|xz -dc
fd377a585a000004e6d6b4460200210116000000742fe5a3e006d7010c5d
0018698865079cf6752c9e9a501a87a798b4844f9fcfdaaf87733b9d8239
48c816d860a938767f6cb81299f3e8a638effe3068c0e096a8949c81d706
7dff3ec44e5df185b3a48e5b5857724386e8c37cfbd5c856b12614ee78ec
c41df4db3aea71fd3a8fa474905609f78eb3fd66e246557965e4ab6dfd67
efbd9202f542ded9cf98a6401ee2d23afb2f544bd2442c6f428fd612397c
f2c6ec50847ddccc5832185e487712e5a7676b97058d7e485d5a3536166a
44ab3c689c93073cdda73b5306a83c4cd268e79db238bfa2d08ac912a578
75020bc7828342d5a62ce367aff7fd89290336128d119fa4272da2b2a79f
5973c71935af054f2d91c1bd3ea4847a3502d6dc8c975114dacf8a4de600
622d80986dbb0cd00001a802d80d00001b16e2a7b1c467fb020000000004
595a
X

Provalo online!


0

Rubino , 362 byte

puts"5r0afnfm8wyke8tfy1pwt7xnuaxyh3wodfp7bhsdufyw0xbdp1pumrz2xir652tuc0ss9oec8yad9vefivd66j126wybhefgk2lv38uqqiur11u26q275jk3h2ucithd59awpaenqpqi1pszh52179zw0ddqtbrvo6kyrrgv8c34pqrp83j8estjp63v29t4hqp9yg2hhzjlq1e9zqx6gh20n9lsttimz3nbq060ritrphxaru7quwmv3oujhd9xjddpbacq4bnpf270znhgto59yn0980itylf95pxw9x7rvkvi7mfql1sx46puo8rg4dq0".to_i(36).to_s(2).rjust(1679,?0)

Numero intero scritto nella base 36. Esiste sicuramente un modo più efficiente per comprimere l'intero, ad esempio con zlibo base64.

Provalo online!


350 byte se: (1) usi "% b" per la formattazione anziché to_s, (2) anteponi? 0 * 6 invece di chiamare rjust
GB

0

[C ++ (VC ++) (ma testato anche con gcc)], 585 byte

#define l(x,y)for(int x=0;x<y;x++)
void f(){const char*a="02A800505012Y595Y240U180YD0Y1A0Y540YF80V61C618800321A3186BEFBEF80X10Y40W20YFC001F0X1861C620200868639AFBEFBE0W40C0100180Z83003F0607C00C001008041030101860400C430Z19800310C018604040804101804403008802020808080800600C030047580080800107C002174B604E4FEE1C1B80283B20507E40A0C08360U3820Z751554E00AA0Z140ZF80Z7FC00380E00C0060340160CC06611414422448804510Z8420010040Z940079F4F0";int x=1679;l(i,365){int d=a[i],c=0;d-=(d>47&d<58)?48:((d>64&d<71)?55:0);if(d>70&d<91)c=91-d,d=a[i-1];for(c;c>=0;c--)l(j,4){if(x--)cout<<(int)((d&(8>>j))>0);}}}

Provalo online!

Versione ungolfed (manca l'interruzione dopo il 1679 ° elemento e va fino al 1680):

#include <stdio.h>
#include <iostream>
using namespace std;
int main()
{
    const char arecibo[]="02A800505012Y595Y240U180YD0Y1A0Y540YF80V61C618800321A3186BEFBEF80X10Y40W20YFC001F0X1861C620200868639AFBEFBE0W40C0100180Z83003F0607C00C001008041030101860400C430Z19800310C018604040804101804403008802020808080800600C030047580080800107C002174B604E4FEE1C1B80283B20507E40A0C08360U3820Z751554E00AA0Z140ZF80Z7FC00380E00C0060340160CC06611414422448804510Z8420010040Z940079F4F0";
    int i = 0,j;
    while (i<sizeof(arecibo)-1)
    {   
        char digit = arecibo[i];
        int count=0;
        if (digit >= '0' & digit <= '9')
        {
            digit -= '0';
        }
        else if (digit>='A'& digit<='F')
        {
            digit -=  'A'-10;
        }
        else if (digit > 'F'&digit<='Z')
        {
            //digit does not contain any valid hex digit in this case
            count = 'Z' - digit+1; //digit = Z means repeat 2 more times...
            digit = arecibo[i - 1];
        }
        for (count; count >= 0; count--)
        {
            for (j = 0; j<4; j++)
            {
                cout << (int)(((digit)&(8 >> j))>0);
            }
        }
        i++;
    }
    return 0;
}

come spiegazione: ho concatenato le 73 righe di output del campione fornite a una riga lunga. li ho codificati in esadecimali in cui l'ordine dei bit è msbfirst (usando questo programma https://github.com/Marc-Bender/longBinaryStreamToHex/releases/download/addedErrorCode-4/longBinaryStreamToHex.exe ) ho ridotto il risultato di circa 70 Cifre esadecimali usando le lettere 'G' - 'Z' come segno per ripetere l'ultima cifra per un certo numero di volte (Z = 2 volte più, Y = 3 volte più ...) il resto dovrebbe essere relativamente autoesplicativo per i golfisti del codice . abusare del preprocessore per accorciare i loop, abusare ,dell'Operatore e simili.

Il formato di output è un flusso ininterrotto di 1679 valori 0/1.


prima che qualcuno chieda alla const è la compatibilità con VC ++ (con cosa è stato fatto il principale lavoro di sviluppo)
der bender

@ceilingcat, penso che puoi anche cortocircuitare aggiungendo la tua inclusione nella sezione header ...
der bender


0

Perl 6 , 348 byte

{"000000"~:36<5r0afnfm8wyke8tfy1pwt7xnuaxyh3wodfp7bhsdufyw0xbdp1pumrz2xir652tuc0ss9oec8yad9vefivd66j126wybhefgk2lv38uqqiur11u26q275jk3h2ucithd59awpaenqpqi1pszh52179zw0ddqtbrvo6kyrrgv8c34pqrp83j8estjp63v29t4hqp9yg2hhzjlq1e9zqx6gh20n9lsttimz3nbq060ritrphxaru7quwmv3oujhd9xjddpbacq4bnpf270znhgto59yn0980itylf95pxw9x7rvkvi7mfql1sx46puo8rg4dq0>.base(2)}

Basato sulla soluzione Java di Benjamin Urquhart .

Utilizza un flusso diretto di 0 e 1 caratteri. Il link seguente ha del codice per preimpostare l'output.

Provalo online!


0

Tcl , 366 byte

binary scan [binary decode base64 QBUACgpIRKSpqkoCAAAAgAEAsAAAWAAAKgAAHwAAAGA4hhEATFiMYX3f9wEAAAgAIAAAAAQA8AOADwAAGIZjBAQQFsZZ3/d9AAAAAgMIgAEAwQD8YOADMAAIECAIDAgYBgIwwgCAGQCMMIBhICAQIAgYIAIMEAEEBAEBAQFgAAMMIK4BEBAACD4AhC5tICd/h4MdQMFNoOAnUDAQbAAAAAAcBACuqCoHUAUAKADwAQD+A8ABBzAABiyABjNghigoQiQSAaIIACEEgAACACkAni8P] b* z
puts [join [regexp -all -inline .{23} $z] \n]

Provalo online!


0

C ++ (con libreria multi-precisione Gnu), 359 byte

Questo genera la stringa come una riga. Utilizza '1' per 0 e '0' per 1: /

Legge semplicemente la stringa incorporata come base 62 e la stampa come base 2.

Utilizzare g++ -g arecibo.cpp -lgmp -lgmpxxper compilare e collegare

#include<gmpxx.h>
main(){mpz_out_str(stdout,2,class_mpz("vuXXKBYAu1hPsJPbFSf49akyFd0bjJbMIV3upYndU8kYFPsXcpRUK6c9qnzLfORxkxGL7ZfoSwgSxFbCrydjHL603QcxexopAzoYAcAyEiENJJU2vQA2zM8NDbeY6nHgL8rfFoPJaclwxx6TeKeOEknEQHzp7C4la3o8xijBQLOVweFZ1CI9dXy2VQhgnuwF5FeW5mQ909pRMxhn6G3RJ1QEtkS7oGMZYHM03fh4fj391IoYLGVv3iUVuTrV2ghz9CUa9hfGYrdhGoVE2w1inYalYl",62).get_mpz_t());}

Non sono riuscito a farlo funzionare fino a quando non ho sostituito class_mpzconmpz_class
ceilingcat il

0

Perl 6 , 276 byte

:122[q{3tD!gLF['u#.K>'uCG8cvJZ[on1Z<D!	`Fhqq-_V'"qQn+n0h\:b,vXjo&1TMFaW;wvX;eUS
(ueelNSu,y93\kjGI&?UU/38 :ndi4Y5cyC+ME\g7LWaS;QLjtD^L+aVd(XW%gy\8'Eqk-+f72S5J?(r5!m^5px T[Z'3&jd0lZ'/x%#(}.ords].base(2)~~S/.//.say

Provalo online!

Output come una serie di 1679 0s e 1s. Puoi averlo su linee diverse aggiungendo .comb(23)>>prima disay .

Spiegazione:

:122["...".ords]                     # Convert the string from base 122
                .base(2)             # To base 2
                        ~~S/.//      # Remove the leading 1
                               .say  # And print

Probabilmente posso salvare byte utilizzando invece l'output come numero intero a 1679 bit o invertendo la rappresentazione dei bit.


0

C ++ (gcc) , 748 byte

#define l(X,Y)if(z[i]==#X[0])z.replace(i,1,#Y);
void f(){std::string z = {"ab1eeedala1ebeeheal1mmma1fa1g1eeeeeeea1a1alddhgdbcdgdacedgdacedgdeeedgdndgddhgqiafbcag1dbfa1blceafafbcegcinnnlddhgmddegddhgb1ddelcidbnlddhgqqiafag1hedeblcebcaf1acegcinnnlddhgmhcdegdacdagb1bfda1lcibfhcildacdaga1d1d1almhcheagbqch1blhcmbqgdacachghcmbqgbqch1blmh1d1aga1hfd1aledcd1aledeheaga1heheblmdbqgbcdchga1af1efdga1hedbla1bndala1b1f1ea1fflh1aia1acccl1f1bibff1ldeebf1fla1h1ebfccla1h1ebfbla1bffdalddhgaibedblaieemeeeeelaideeeealdh1ehldcidalhcccidlbihf1hlafdafbgacedefblfachfacagemebeemagema1ma1magbememhgbeb1b1hgbedehghea1edalfcacieacca0"};for(int i=0;i<1751;i++){l(q,cb)l(n,fi)l(m,ae)l(i,c1)l(h,ba)l(g,0l)l(f,0c)l(e,01)l(d,bb)l(c,11)l(b,aa)l(a,00)l(l,\n)printf("%c",z[i]);}}

Provalo online!

Sostituendo la sottostringa più utilizzata con un nuovo personaggio fino a quando non ne vale più la pena



0

Python 3 , 331 byte

exit(''.join(bin(i)[3:]for i in b'`UP@JB`IDQKJjjd`@@@@@L@@Ah@@CP@@J`@@_@@@@@LNLLP@FPtXpu}}}|@@@@`@@`@@@A@@A~@@~@@@CCCcDA@DMCGM____@@@@HF@H@L@@PX@_`pO`A`@HA@HHF@`LLB@FHX@@s@@Xa`CC@`HD@``L@b@XAD@PDDA@PD@C@F@X@ck@A@P@BCx@DKi[@gI\x7f\\NC\\@TGY@hOrAPXDFp@@@@@\\D@@zbjipAU@@B`@Gp@@\x7fx@G@\\@X@LAh@lFXCLHhJHQHdPBJH@DHP@H@`@Dh@OOix')[1:])

Provalo online!

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.