A mensagem de Arecibo é uma mensagem de rádio interestelar de 1974, com informações básicas sobre a humanidade e a Terra, enviadas ao aglomerado de estrelas globulares M13, na esperança de que a inteligência extraterrestre possa recebê-la e decifrá-la ... A mensagem consistia em 1.679 dígitos binários, aproximadamente 210 bytes ...
O número 1.679 foi escolhido por ser um semiprime (o produto de dois números primos), para ser organizado retangularmente como 73 linhas por 23 colunas. O arranjo alternativo, 23 linhas por 73 colunas, produz um conjunto ininteligível de caracteres (assim como todos os outros formatos X / Y).
Esta é a mensagem com cor adicionada para destacar suas partes separadas. A transmissão binária real não carregava informações de cores.
Sua tarefa é gerar a mensagem Arecibo na organização exata de 23x73 mostrada na imagem. Qualquer um desses formatos de saída é aceitável:
- Texto, usando um caractere para uns e outro para zeros (usando as regras usuais para separação de linhas)
- Uma matriz 2D de dois valores distintos
- Uma imagem 23x73 com duas cores distintas
- Um fluxo ininterrupto de 1679 itens de dois valores distintos (ou seja, qualquer um dos formatos acima, mas simples).
- Um número inteiro de 1679 bits. Indique a ordem de bits e bytes (endianness) em sua solução.
Para sua comodidade, aqui está uma versão passível de cópia (também um exemplo de saída em formato de texto):
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 o seu idioma, por algum motivo, possuir um built-in para a Mensagem Arecibo, você não poderá usá-lo.
Boa sorte!
ATUALIZAÇÃO: Aceitei a resposta 05AB1E, pois era a primeira a ser mais curta que a mensagem original. Não deixe que isso dissuadi-lo de novas soluções.
ATUALIZAÇÃO 2019-09-09: A resposta aceita foi movida para uma nova resposta 05AB1E, pois obsoleta a resposta 05AB1E anterior. O mesmo ponto vale para a atualização anterior; novas soluções ainda são bem-vindas.
fonte
Respostas:
05AB1E , 182 bytes
Experimente online! (usa
1
para 0 e0
para 1, conforme permitido pela pergunta).Experimente online! (5 bytes a mais,
0
para 0 e1
para 1, novas linhas adicionadas para facilitar a leitura).A maior parte do código é uma constante N de base 255, o restante é um decodificador do Sistema Numérico Assimétrico , usando probabilidades codificadas de 75% / 25% (a frequência real de 0 é 76,35%, o que é tão próximo a 75% que economizaria apenas 1,2 bits na carga, enquanto os 75% agradáveis e redondos nos permitem salvar vários bytes no decodificador).
Aqui está o codificador ANS que gerou a constante: Experimente online!
fonte
05AB1E ,
215210200 bytesEconomizou 15 bytes graças ao Magic Octopus Urn
Experimente online! ou com formatação adicional
Cadeia de caracteres trinária codificada em Base-255 com ocorrências de
0000
substituídas por2
.fonte
0000
com2
por mais 9 bytes. - pastebin.com/aZ6tHxjx para 201Java,
688 678 590 379361 bytesRetorna uma string.
-10 bytes retornando o fluxo bruto (resposta antiga)
-88 bytes usando números 10 base (obrigado @ceilingcat!)
-211 bytes (eu sabia que poderia ser jogado golfe!) Usando um BigInteger codificado em base 36 (obrigado @JollyJoker !)
-18 bytes usando um número inteiro codificado diferente (obrigado novamente @JollyJoker)
Experimente online!
Explicação:
fonte
Geléia , 213 bytes
Experimente online!
Eu brinquei com a codificação Huffman, mas as melhorias no tamanho dos dados foram superadas pelo código extra. Como tal, esta é simplesmente uma versão codificada na base 250 da saída desejada. A saída consiste em um número inteiro que, quando decodificado como base bijetiva 2, produzirá a lista 1D de 1s e 2s. Obrigado @Emigna por apontar a alteração nas regras.
Experimente online - com mais decodificação para demonstrar a saída!
Se uma codificação binária mais convencional for preferida, aqui está uma que codifica uma representação inteira da mensagem binária invertida. O bit mais significativo do número inteiro representa o início da mensagem.
fonte
Brainfuck,
236020081938 bytesExperimente online!
Provavelmente vou jogar isso ainda mais em breve.
fonte
Peixe morto ~ ,
111510881084 bytesExperimente online!
Se alguém tiver paciência para jogar mais, eu saúdo você com antecedência. : P
-27 bytes imprimindo 10s e 100s nos locais onde aplicável.
-4 bytes imprimindo três 1000 e um 1001 na linha 3
fonte
Piet , 1763 codels
Emite um fluxo de 0s e 1s (sem quebras de linha).
Codel size 1:
Codel tamanho 4, para facilitar a visualização:
Explicação
Notas
O programa segue um caminho em espiral, no sentido horário, da parte superior esquerda para o centro. Os blocos pretos dispersos que seguem aproximadamente as diagonais são o controle de fluxo. Aqui está o rastreio do NPiet .
Estou trabalhando nisso desde o dia em que esse desafio surgiu, mas demorou um pouco para que a mensagem fosse "gravada" na imagem! Escrevi os loops finais e o valor da sentinela primeiro e depois construí a mensagem do centro para o exterior. (Como o Piet sempre inicia a execução a partir do canto superior esquerdo, eu esperava ter que embaralhar e girar a imagem para evitar excesso de espaço em branco, mas ela se encaixava perfeitamente!)
Curiosidade: a codificação de execução no Piet não economiza (por si só) espaço. São necessários n codelos de uma cor para inserir o valor n na pilha ou n codéis de cores diferentes para inserir tantos 1s na pilha. Portanto, é o mesmo número de codéis de qualquer maneira. Mas os números maiores que o RLE fornece significa que você pode usar truques aritméticos (por exemplo, em vez de pressionar 9, você pode pressionar 3, duplicar e multiplicar) para reduzir o número de codelos e blocos engraçados para preencher o espaço em branco disponível.
Eu não tinha certeza de como contar a pontuação para as entradas de Piet. Encontrei alguns que parecem contar todos os codelos, e outros que explicitamente contam apenas aqueles usados ativamente. Eu apenas contei todos eles; ignorar codels brancos (mesmo aqueles pelos quais o programa nunca passa) parece semelhante a ignorar espaços em branco em uma linguagem de programação mais típica.
Ah, e agora (duas horas após a postagem) percebi que perdi o último tempo trabalhando nisso. Eu queria cortar a última linha e coluna quase completamente branca, então embaralhei as coisas ... incluindo os blocos pretos de controle de fluxo. Mas as bordas da imagem funcionam da mesma forma que o preto! Se eu tivesse me lembrado disso, não precisaria gastar tanto tempo intrigando os meandros dos PDs e CCs ...
fonte
C # (Compilador interativo do Visual C #) ,
366332329319 bytesSubstitua todas as instâncias de
␀
por\0
para testar.Experimente online!
C # (compilador interativo do Visual C #) , 305 bytes, 210 caracteres
Mesmo com o anterior, substitua por
␀
com\0
para testar. Saída comoIEnumerable<string>
.Experimente online! (Cortesia de Jo King)
fonte
++
in12-i++%2
é um nop (pelo menos, funcionou para mim quando o removi)Perl 6 , 368 bytes
Experimente online!
A cadeia longa é a mensagem como um único número base-36 (com um único prefixo de 1 bit para preservar os zeros iniciais) que é então convertido novamente em binário e impresso 23 bits por vez.
fonte
>>.say
e&{S/.//}
salvar bytes. Você já pensou em usar uma base diferente?Wolfram Language (Mathematica) , 383 bytes
Experimente online!
fonte
Node.js , 333 bytes
Retorna uma sequência binária de 1.679 caracteres.
Experimente online! (com saída formatada)
JavaScript (ES8), 413 bytes
Retorna uma sequência binária de 1.679 caracteres.
Experimente online! (com saída formatada)
fonte
Bubblegum,
275236 bytesExperimente online!
fonte
ferramentas bash + GNU, 351 bytes
TIO
fonte
MathGolf ,
223220 bytesExperimente online!
Explicação
fonte
L/n
para o rodapé, na verdade são 220 bytes. É possível salvar mais bytes portando as respostas 05AB1E / Java (usando esse número inteiro compactado , convertê-lo em base-3 e substituir todos2
s por0000
s)?2
para♫░╞
? EDIT: Não importa. Vejo que você não tem uma Conversão Base embutida (exceto binário / hexadecimal) para converter em base-3?+
rodapé tambémPerl 5 , 460 bytes
Experimente online!
fonte
Python 2 , 336 bytes
Experimente online!
Imprime uma sequência de bytes
fonte
Java (OpenJDK 8) , 364 bytes
Experimente online!
Explicação: Primeiro teve
n->new java.math.BigInteger(str,36).toString(2)
, bastava converter um número de raiz 36 em binário, mas isso precisava de nove caracteres extras para zeros iniciais. Então, eu tive a idéia de codificar no comprimento da execução alguns zeros como dois. Um comprimento de quatro zeros parece minimizar o comprimento da base 36, portanton->new java.math.BigInteger(str,36).toString(3).replaceAll("2","0000")
Consulte a discussão sob esta resposta para obter a correção de bug principal de zeros por @KevinCruijssen
fonte
[Python 2] , 345 bytes
Codifiquei o comprimento das cadeias de 0s como um byte começando em chr (31). Então codifiquei os 10101 restantes como números binários, começando em chr (70) até chr (126). Strings binárias que não se encaixavam foram divididas em pedaços menores.
Editar: reduzido para 326 bytes. Obrigado Jo King
Edit: Corrigido um bug no programa gerador de código
Edit: Edição Final
fonte
o
uma variável.Zsh , 577 bytes
experimente online !!
Lógica de codificação personalizada usada. A string
S
tem 421 caracteres e pode ser compactada um pouco mais. As letrasa-w
representam0
s repetidos . Os números1-9
representam1
s repetidos . As letrasx y z
representam10 100 1000
respectivamente.Talvez eu devesse ter tentado a codificação de pares de bytes ou o Ascii85 .
fonte
Bash ,
702697 bytesExperimente online!
fonte
Ruby , 362 bytes
Inteiro escrito na base 36. Certamente, existe uma maneira mais eficiente de compactar o número inteiro, por exemplo, com
zlib
oubase64
.Experimente online!
fonte
[C ++ (VC ++) (mas também testado com gcc)], 585 bytes
Experimente online!
Versão ungolfed (falta a ruptura após o 1679th elemento embora e vai até o 1680th):
como uma explicação: concatenou as 73 linhas de saída de amostra fornecidas para uma linha longa. codifiquei-os em hexadecimal, onde a ordem dos bits é msbfirst (usando este programa https://github.com/Marc-Bender/longBinaryStreamToHex/releases/download/addedErrorCode-4/longBinaryStreamToHex.exe ) a saída disso em cerca de 70 Dígitos hexadecimais usando as letras 'G' - 'Z' como um sinal para repetir o último dígito por um determinado período de tempo (Z = mais duas vezes, Y = mais três vezes ...) o resto deve ser relativamente auto-explicativo para os jogadores de código . abusar do pré-processador para encurtar loops, abusar do
,
Operador e similares.Formato de saída é um fluxo ininterrupto de 1679 0/1-valores.
fonte
Perl 6 , 348 bytes
Baseado na solução Java de Benjamin Urquhart .
Usa um fluxo direto de 0 e 1 caracteres. O link abaixo tem algum código para prettify a saída.
Experimente online!
fonte
Tcl , 366 bytes
Experimente online!
fonte
C ++ (com biblioteca multi-precisão Gnu), 359 bytes
Isso gera a string como uma linha. Ele usa '1' para 0 e '0' para 1: /
Ele simplesmente lê a string incorporada como base 62 e a imprime como base 2.
Use
g++ -g arecibo.cpp -lgmp -lgmpxx
para compilar e vincularfonte
class_mpz
mpz_class
Perl 6 , 276 bytes
Experimente online!
Saídas como uma série de 1679 0s e 1s. Você pode tê-lo em linhas diferentes adicionando
.comb(23)>>
antes dosay
.Explicação:
Provavelmente, posso salvar bytes usando a saída como um inteiro de 1679 bits ou revertendo a representação de bits.
fonte
C ++ (gcc) , 748 bytes
Experimente online!
Substituindo a substring mais usada por um novo caractere até que não valha mais a pena
fonte
Python 3 , 331 bytes
Experimente online!
fonte