Com base nesta pergunta Math.SE ; número copiado desta resposta . Número originalmente de um vídeo Numberphile , é claro.

Sua tarefa é gerar o seguinte número primo de 1350 dígitos:

888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888111111111111111111111111888888111111111111111111111111888888111111811111111118111111888888111118811111111118811111888888111188811111111118881111888888111188811111111118881111888888111888811111111118888111888888111888881111111188888111888888111888888111111888888111888888111888888888888888888111888888111888888888888888888111888888111888888888888888888111888888811188888888888888881118888188811188888888888888881118881188881118888888888888811188881118888111888888888888111888811111888811118888888811118888111111188881111111111111188881111111118888111111111111888811111111111888811111111118888111111111111188881111111188881111111111111118888811118888811111111111111111888881188888111111111111111111118888888811111111111111111111111888888111111111111111111111111118811111111111111111111111111111111111111111111062100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001

Opcionalmente, você pode incluir novas linhas na saída.

Regras

• Isso é complexidade kolmogorov , portanto, não há entrada.
• Seu programa deve terminar dentro de uma hora em um computador padrão - se estiver próximo, usarei o meu para testes. Se o seu programa for executado por mais de um minuto ou não terminar no TIO, inclua o horário no seu computador.
• Isso é código-golfe , então o código mais curto, em bytes, vence.

Geléia , 74 71 69 68 66 bytes

“©ạ-3ṗÇñ"ỤḍV8żṢ?ḤsMVE[,Ṃƭ"ḞÇsẇʂ(ụFsẠʂẆŀṣ’ḃ19ĖŒṙị⁾81s30m0Z062 ȷ446‘

Experimente online!

Como funciona

O literal “©ạ-3ṗÇñ"ỤḍV8żṢ?ḤsMVE[,Ṃƭ"ḞÇsẇʂ(ụFsẠʂẆŀṣ’substitui todos os caracteres com seus pontos de código na página de códigos do Jelly e interpreta o resultado como um número de base 250 (bijetivo), produzindo o número inteiro a seguir.

103877200905186099028820568168804302565394743652609510039112658230540917082292838565138059974

Em seguida, ḃ19converte esse número na base bijetiva 19, produzindo a seguinte matriz de dígitos.

16,14,18,12,19,11,3,12,5,10,3,14,4,9,3,15,4,8,3,6,6,4,4,7,3,4,10,3,4,6,3,3,12,3,4,5,3,2,14,3,4,4,3,7,9,4,3,4,3,8,9,4,3,3,3,9,8,4,4,2,3,9,8,5,3,2,3,9,8,6,3,1

Agora, ĖŒṙenumera os dígitos e executa decodificação no comprimento da execução, produzindo a seguinte matriz.

1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,6,6,6,6,6,6,6,6,6,6,6,7,7,7,8,8,8,8,8,8,8,8,8,8,8,8,9,9,9,9,9,10,10,10,10,10,10,10,10,10,10,11,11,11,12,12,12,12,12,12,12,12,12,12,12,12,12,12,13,13,13,13,14,14,14,14,14,14,14,14,14,15,15,15,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,17,17,17,17,18,18,18,18,18,18,18,18,19,19,19,20,20,20,20,20,20,21,21,21,21,21,21,22,22,22,22,23,23,23,23,24,24,24,24,24,24,24,25,25,25,26,26,26,26,27,27,27,27,27,27,27,27,27,27,28,28,28,29,29,29,29,30,30,30,30,30,30,31,31,31,32,32,32,33,33,33,33,33,33,33,33,33,33,33,33,34,34,34,35,35,35,35,36,36,36,36,36,37,37,37,38,38,39,39,39,39,39,39,39,39,39,39,39,39,39,39,40,40,40,41,41,41,41,42,42,42,42,43,43,43,44,44,44,44,44,44,44,45,45,45,45,45,45,45,45,45,46,46,46,46,47,47,47,48,48,48,48,49,49,49,50,50,50,50,50,50,50,50,51,51,51,51,51,51,51,51,51,52,52,52,52,53,53,53,54,54,54,55,55,55,56,56,56,56,56,56,56,56,56,57,57,57,57,57,57,57,57,58,58,58,58,59,59,59,59,60,60,61,61,61,62,62,62,62,62,62,62,62,62,63,63,63,63,63,63,63,63,64,64,64,64,64,65,65,65,66,66,67,67,67,68,68,68,68,68,68,68,68,68,69,69,69,69,69,69,69,69,70,70,70,70,70,70,71,71,71,72

Em seguida, ị⁾81indexa a sequência 81 , substituindo números ímpares pelo caractere 8 , número par pelo caractere 1 . Depois, s30divide o resultado em pedaços de comprimento 30. Exibindo um pedaço por linha, o resultado é o seguinte.

888888888888888811111111111111
888888888888888888111111111111
888888888888888888811111111111
888111111111111888881111111111
888111111111111118888111111111
888111111111111111888811111111
888111111888888111188881111111
888111188888888881118888111111
888111888888888888111888811111
888118888888888888811188881111
888111111188888888811118881111
888111111118888888881111888111
888111111111888888881111888811
888111111111888888881111188811
888111111111888888881111118881

Agora, m0concatena a matriz de partes com uma cópia invertida de si mesma. Depois, Zfecha o resultado, transpondo linhas e colunas.

888888888888888888888888888888
888888888888888888888888888888
888888888888888888888888888888
888111111111111111111111111888
888111111111111111111111111888
888111111811111111118111111888
888111118811111111118811111888
888111188811111111118881111888
888111188811111111118881111888
888111888811111111118888111888
888111888881111111188888111888
888111888888111111888888111888
888111888888888888888888111888
888111888888888888888888111888
888111888888888888888888111888
888811188888888888888881118888
188811188888888888888881118881
188881118888888888888811188881
118888111888888888888111888811
111888811118888888811118888111
111188881111111111111188881111
111118888111111111111888811111
111111888811111111118888111111
111111188881111111188881111111
111111118888811118888811111111
111111111888881188888111111111
111111111118888888811111111111
111111111111888888111111111111
111111111111118811111111111111
111111111111111111111111111111

0é um nilad inseparável; portanto, o resultado de antes é impresso (sem quebras de linha) e o valor de retorno é definido como 0 .

62é outro nilad não analisável; portanto, o resultado de antes ( 0 ) é impresso e o valor de retorno é definido como 62 .

ȷ446é mais uma nilad inseparável. 62 é impresso e o valor de retorno é definido como 10 ⁴⁴⁶ .

Por fim, ‘incrementa o resultado. O resultado final ( 10 ⁴⁴⁶ + 1 ) é impresso quando o programa termina.

SOGL V0.12 , 81 78 75 73 bytes

$!╚Qαūπōθ(└↓Υ8Π⁶!√|ΠΚψ░⅜Υ‛⁷>∙↓ts3]δεΧ‰“8«─'½Κ81¹¹I⌡_¹◄ø∑'¹n╬³0621"η“⌡01⁰∑

Experimente aqui!

Explicação:

...“                 push a big number of the RLE lengths of the top part
    8«─              convert from base 10 to base 16 (15 was the max length, and making it base 15 wasn't worth it)
       '½Κ           prepend to the array 48
          81¹        push [8, 1]
             ¹       wrap those two in an array
              I      rotate clockwise, resulting in [[8, 48], [1, 2], [8, 9], [1, 12], ...]
               ⌡_¹   flatten (iterate over, splat current items contents on stack, collect the contents in an array)
                  ◄  run-length decode

ø∑                   join as a string
  '¹n                split into lines of length 15
     ╬³              palindromize horizontally with no overlap
       0621          push 0, 6, 2, and 1
           "η“       push 445
              ⌡      that many times do
               0       push 0
                1    push 1
                 ⁰∑  join the stack together in a string

Geléia , 136 bytes

“ßṪṭAƭẠvµM⁾ṖOḥ⁻Ɠ×Ṣ~*pṭẒFỵṿ¦4ÇḟọLÑOcKɲ⁶2*Ḣɲ’b45;@€1ẋ/€ø“Œ\⁴rrNỊġ:,xƙŒ#ṠƲQçḷĠ%&⁻ɼiḂŀB<Ȧƈg(Ṇb>TḥḄ|ḃṘƬ#l7ƇØṃ’b94;@€8ẋ/€ðżF;0;6;2;1;0ẋ445¤;1Ḍ

Experimente online!

Explicação (números encurtados)

“ßṪṭ...*Ḣɲ’b45;@€1ẋ/€ø“Œ\⁴...ƇØṃ’b94;@€8ẋ/€ðżF;0;6;2;1;0ẋ445¤;1Ḍ  Main link
“ßṪṭ...*Ḣɲ’b45;@€1ẋ/€                                             Run-length encoded 1s
“ßṪṭ...*Ḣɲ’                                                      The base-45 encoding of the list of the run-lengths of 1s
           b45                                                    in base 45
                €                                                 For each element
              ;@                                                  prepend
                 1                                                1
                    €                                             For each sublist
                   /                                              Reduce over
                  ẋ                                               Repeat list (this gets a bunch of lists of 1s)
                     ø“Œ\⁴...ƇØṃ’b94;@€8ẋ/€                       Run-length encoded 8s
                      “Œ\⁴...ƇØṃ’                                 The base-94 encoding of the list of the run-lengths of 8s
                                 b94                              in base 94
                                      €                           For each element
                                    ;@                            prepend
                                       8                          8
                                          €                       For each sublist
                                         /                        Reduce over
                                        ẋ                         Repeat list (this gets a bunch of lists of 8s)
                                           ðżF;0;6;2;1;0ẋ445¤;1Ḍ  With both of the previous lists of lists, construct the final string
                                            ż                     Interleave them
                                             F                    Flatten it
                                              ;0                  Append 0
                                                ;6                Append 6
                                                  ;2              Append 2
                                                    ;1            Append 1
                                                      ;           Append
                                                       0ẋ445¤     (Nilad)
                                                       0          0
                                                        ẋ445      445 times
                                                             ;1   Append 1
                                                               Ḍ  Convert decimal digits to a number

-121 bytes graças a Dennis usando “...’literais em vez de números normais

Geléia ,  133 84  73 bytes

“÷iþṃL7[ḲʂƘⱮ=ƬƤ¬`RẹŀẹY÷n£ị€ıø&ḟ"gPƲ_ÇḊṪ’b⁴48;ĖŒṙḂ×7‘s15m€0F;“¡©£¢‘Ḍ×ȷ446‘

Experimente online! (rodapé formata o número decimal com as dimensões que produzem o brasão).

Quão?

Uma forma codificada na execução de um formato binário do lado esquerdo do brasão de armas 8e 1até a linha anterior àquela que começou 0621refletida com a 0621adicionada e, em seguida, multiplicada por 10 ⁴⁴⁶ e incrementada.

“...’b⁴48;ĖŒṙḂ×7‘s15m€0F;“¡©£¢‘Ḍ×ȷ446‘ - Link: no arguments
“...’                                  - base 250 number
     b⁴                                - to base 16
       48;                             - prepend a 48
          Ė                            - enumerate [[1,48],[2,12],[3,3],[4,12],[5,3],...
           Œṙ                          - run-length decode (48 1s then 12 2s then ...)
             Ḃ                         - modulo by 2 (vectorises) evens->0 odds->1
              ×7                       - multiply by 7 (vectorises)
                ‘                      - increment (vectorises) - now all 8s and 1s
                 s15                   - split into chunks of length 15
                    m€0                - reflect each chunk
                       F               - flatten
                         “¡©£¢‘        - code-page indices = [0,6,2,1]
                        ;              - concatenate
                               Ḍ       - from decimal list to number
                                 ȷ446  - 10^446
                                ×      - multiply
                                     ‘ - increment

Carvão , 107 104 98 96 87 79 bytes

Ｅ³⁰✂”}∧Pt→8⌕ＬＪε`‽∨↑¬KαfＧⅉKＭκ⎆wp◧⪫⊘^≦#⁸¹"π✂×OγX‹nI”×ι¹⁵×⊕ι¹⁵‖ＣＭ²⁸←621Ｍ²⁵¦¹⁴1ＵＢ0

Experimente online! Link para código detalhado para explicação

Próton , 368 bytes

s=(map("8"&(*),[93,6,6,1,1,6,2,2,6,3,3,6,3,3,6,4,4,6,5,5,6,6,6,6,18,6,18,6,18,7,16,4,3,16,3,4,14,4,4,12,4,4,8,4,4,4,4,4,4,4,4,4,5,5,5,5,8,6,2]),map("1"&(*),[24,24,6,10,6,5,10,5,4,10,4,4,10,4,3,10,3,3,8,3,3,6,3,3,3,3,3,3,3,3,3,1,3,3,2,3,3,3,3,3,5,4,4,7,14,9,12,11,10,13,8,15,4,17,2,20,23,26,44]))
q=''.join(s[0][i]+s[1][i]for i:0..len(s[0]))
print(q+'0621'+'0'*445+'1')

Experimente online!

Ruby , 180 bytes

s=0;"".unpack('H*')[0].split(?f).map{|a|a.chars.map{|c|s^=2**c.to_i(16)};t=("%015b"%s).gsub ?0,?8;$><<t+t.reverse};puts'0621'+?0*445+?1

Experimente online!

178 bytes + 2 bytes para -Kn(força a codificação ASCII.)

43 caracteres na maioria imprimíveis entre as primeiras aspas. Hexdump:

00000000: 733d 300a 22ff f012 3456 789a bff5 f6f7  s=0."...4Vx.....
00000010: ff8f 4f3f 012f ff8b fef7 af69 df45 8cf0  ..O?./.....i.E..
00000020: 1237 bf6a f59f 48f2 37f1 6f04 5f3f 12f0  .7.j..H.7.o._?..
00000030: 222e 756e 7061 636b 2827 482a 2729 5b30  ".unpack('H*')[0
00000040: 5d2e 7370 6c69 7428 3f66 292e 6d61 707b  ].split(?f).map{
00000050: 7c61 7c61 2e63 6861 7273 2e6d 6170 7b7c  |a|a.chars.map{|
00000060: 637c 735e 3d32 2a2a 632e 746f 5f69 2831  c|s^=2**c.to_i(1
00000070: 3629 7d3b 743d 2822 2530 3135 6222 2573  6)};t=("%015b"%s
00000080: 292e 6773 7562 203f 302c 3f38 3b24 3e3c  ).gsub ?0,?8;$><
00000090: 3c74 2b74 2e72 6576 6572 7365 7d0a 7075  <t+t.reverse}.pu
000000a0: 7473 2730 3632 3127 2b3f 302a 3434 352b  ts'0621'+?0*445+
000000b0: 3f31                                     ?1

Quão?

Todo mundo estava usando a codificação de comprimento de execução, então eu queria tentar algo diferente.

A versão formatada da "imagem" do primo pode ser separada em duas partes - uma grade 30x30 de 8 e 1 e uma segunda seção, na maioria das vezes, zeros que podem ser codificados. Focando a primeira parte, observamos que é simétrica no centro; portanto, se pudermos produzir a metade esquerda, podemos apenas imprimir metade de cada linha com seu reverso.

Metade de uma linha tem 15 caracteres. Se substituirmos os 8 por zeros, cada linha poderá ser interpretada como um número binário de 15 bits. Convenientemente, na maioria das vezes a distância de edição entre cada linha consecutiva é pequena, então decidi implementar minha solução armazenando a primeira linha s( 888888888888888que passa a ser 0) e aplicando uma série de operações de inversão de bits s, imprimindo o resultado sempre .

Como cada linha tem 15 bits de comprimento, codifiquei essas operações como dígitos hexadecimais - por exemplo, se a operação for b(ou 11), invertemos o bit 11. Algumas linhas diferem em mais de um bit, portanto, exigem uma sequência de caracteres hexadecimais. dígitos. Temos um pouco de sobra ( f) para que possamos usá-lo como um delimitador entre essas strings e também como um valor "não fazer nada". Exemplo abaixo (você pode ver essas linhas na postagem mencionada na pergunta):

Line 3: 000000000000000
Line 4: 000111111111111  <-- flip bits 0 through b
Line 5: 000111111111111  <-- do nothing
Line 6: 000111111011111  <-- flip bit 5

Para juntar tudo isso, codificaríamos 0123456789ab, em seguida , nos separaríamos , sem ffazer nada com f, então 5. Isso funciona porque faremos .split(?f)mais tarde para obter cada conjunto de operações por linha, o que renderá ["0123456789ab", "", "5"]e ""será um não operacional.

A diferença entre as linhas 3 e 4 acima é de longe o conjunto mais longo de edições, e a distância de edição entre duas linhas consecutivas é geralmente de 0 a 2, então eu diria que essa codificação é razoavelmente barata, embora eu tenha certeza de que pode ser melhorado.

Toda a cadeia codificada acaba sendo fff0123456789abff5f6f7ff8f4f3f012fff8bfef7af69df458cf01237bf6af59f48f237f16f045f3f12f0(86 bytes), que obterá toda a grade 30x30. Mas ainda não terminamos ...

Dígitos hexadecimais podem ser representados por 4 bits ( b-> 1100, etc.) Isso significa que, se estivermos dispostos a codificar nossa string 4 bits por vez, em vez de usar bytes, podemos cortar o comprimento da string pela metade. Foi o que eu fiz - o hexdump mostra a string representada em 43 bytes. Depois disso, é só uma questão de usar bacana de Ruby String # descompactar com H*(interpretar como string hexadecimal, alta mordidela primeiro) para expandir a seqüência de 43 bytes para a versão 86-byte que conhecemos e amamos, e loop para cada conjunto de operações lançando bits - para nossa string armazenada se uma operação cque fazemos s ^ 2**c.to_i(16)para virar o bit correspondente.

Após a conclusão de cada conjunto de edições, aumentamos o binário resultante para 15 bits, alternamos todos os 0 para 8 e imprimimos o resultado e seu inverso. Como observado anteriormente, a parte do número após a grade 30x30 pode ser codificada, então fazemos isso como puts'0621'+?0*445+?1.

A sequência codificada final não tem possibilidade de trabalhar no TIO, portanto, a versão do TIO usa escapes, que ainda funcionam, mas são mais longos.

Python 2 , 760 523 329 205 196 bytes

-237 bytes graças a Stephen. -124 bytes graças a Jonathan Frech.

print''.join((ord(j)-34)*'81'[i%2]for i,j in enumerate(":(:((#,#(('$,$'(&%,%&(&%,%&(%&,&%(%'*'%(%(((%(%4%(%4%(%4%)%2%&#%%2%%$&%0%&%&%.%&'&&*&&)&0&+&.&-&,&/&*&1'&'3'$'6*9(<$N"))+'0621'+'0'*445+'1'

Experimente online!

CJam, 532 412 340 231 210 209 bytes

". $ MBZp & 8OIoLs7Rv / BEqN # 1r ~ E $ O% 6 ^ UO = \ z: (Iw] l \ LQ.g.aWf + {2; em | YP'y $: Lc $ i $ GMCg & mRs # y0 * z` Z, C | Hf6; b / o-0 | FNK5R: OIi} {'`CJ} LOXMSA, & vzl5scm5y0 {om = A _ # / wF"' # fm92bs: A; "6NLkB) h% @ {u`hp_v + YK "'# fm92bYb2f + {[A / (\ s: A;)]}% e ~' 0445 * 1

Experimente Online

A codificação de execução expandida da base 92 (a Base 250 levou a caracteres multibyte, portanto, foi necessário ajustar). Além disso, 4341089843357287864910309744850519376é expandido da base 92 e convertido em binário. Um 1 significa que o comprimento da execução é de dois dígitos, 0 significa que é um dígito. Por exemplo, os 4 primeiros dígitos da representação binária são 1101 porque as quatro primeiras execuções são [93,8],[24,1],[6,8],[24,1](93 8, 24 1, etc ...)

JavaScript, 454 450 332 207 204 bytes

-4 bytes graças a Stephen. -125 bytes graças a Shaggy e Dom Hastings.

_=>[...`]






,`].map((j,i)=>'81'[i%2].repeat(j.charCodeAt())).join``+0+621+"0".repeat(445)+1

Há um monte de imprimíveis nesta resposta, então aqui está um hexdump:

00000000: 5f3d 3e5b 2e2e 2e60 5d18 0618 0606 010a  _=>[...`].......
00000010: 0106 0605 020a 0205 0604 030a 0304 0604  ................
00000020: 030a 0304 0603 040a 0403 0603 0508 0503  ................
00000030: 0603 0606 0603 0603 1203 0603 1203 0603  ................
00000040: 1203 0703 1003 0401 0303 1003 0302 0403  ................
00000050: 0e03 0403 0403 0c03 0405 0404 0804 0407  ................
00000060: 040e 0409 040c 040b 040a 040a 0408 040f  ................
00000070: 0504 0511 0502 0514 0817 061a 022c 605d  .............,`]
00000080: 2e6d 6170 2828 6a2c 6929 3d3e 2738 3127  .map((j,i)=>'81'
00000090: 5b69 2532 5d2e 7265 7065 6174 286a 2e63  [i%2].repeat(j.c
000000a0: 6861 7243 6f64 6541 7428 2929 292e 6a6f  harCodeAt())).jo
000000b0: 696e 6060 2b30 2b36 3231 2b22 3022 2e72  in``+0+621+"0".r
000000c0: 6570 6561 7428 3434 3529 2b31            epeat(445)+1

f=
_=>[...`]






,`].map((j,i)=>'81'[i%2].repeat(j.charCodeAt())).join``+0+621+"0".repeat(445)+1

document.write(f())

JavaScript (ES6), 206 205 204 203 198 197 194 bytes

Surgiu isso enquanto trabalhava na solução da i cri everytim , e achava que era diferente o suficiente para garantir a publicação por si própria.

Isso inclui uma carga de não-imprimíveis entre ]e ,siga o link do TIO abaixo para visualizá-lo com escapes Unicode (cada sequência \useguida por 4 dígitos conta como 1 byte).

_=>`],0621ƽ1`.replace(/\D/g,(x,y)=>"810"[y<122?y&1:2].repeat(x.charCodeAt()))

Experimente online

MATLAB / oitava , 319 318 bytes

Esta é a minha primeira tentativa neste desafio. Ainda um pouco grande e provavelmente existem maneiras mais eficientes de fazer isso, mas pensei em publicá-lo de qualquer maneira, pois o método era mais interessante do que apenas compactá-lo.

for i=reshape('|871%871%8%1 8)1 8%1%8$1!8)1!8$1%8#1"8)1"8#1%8#1"8)1"8#1%8"1#8)1#8"1%8"1$8''1$8"1%8"1%8%1%8"1%8"118"1%8"118"1%8"118"1&8"1/8"1#8 1"8"1/8"1"8!1#8"1-8"1#8"1#8"1+8"1#8$1#8#1''8#1#8&1#8-1#8(1#8+1#8*1#8)1#8,1#8''1#8.1$8#1$801$8!1$831''861%891!8K1 0 6 2 1~0~0~0~0`0 1',2,[]);fprintf(repmat(i(2),1,i(1)-31));end

Experimente online!

O método usado aqui é fazer uso de um tipo de esquema de codificação de comprimento de execução.

Começamos com o número original e contamos o número de dígitos consecutivos. Eles são escritos no resultado abaixo como a contagem seguida diretamente pelo dígito (espaço separado para maior clareza).

938 241 68 241 68 61 8 101 8 61 68 51 28 101 28 51 68 41 38 101 38 41 68 41 38 101 38 41 68 31 48 101 48 31 68 31 58 81 58 31 68 31 68 61 68 31 68 31 188 31 68 31 188 31 68 31 188 31 78 31 168 31 48 1 38 31 168 31 38 21 48 31 148 31 48 31 48 31 128 31 48 51 48 41 88 41 48 71 48 141 48 91 48 121 48 111 48 101 48 131 48 81 48 151 58 41 58 171 58 21 58 201 88 231 68 261 28 441 0 6 2 1 4450 1

Se qualquer um dos valores for maior que 95, dividimos isso em vários blocos de 95 ou menos - isso só acontece para os 445 0, que se tornam quatro conjuntos de 95 0 e um conjunto de 65 0. Também preenchemos contagens inferiores a 10 com um 0 para tornar todos os elementos com três caracteres. Isso gera os espaços removidos:

938241068241068061018101018061068051028101028051068041038101038041068041038101038041068031048101048031068031058081058031068031068061068031068031188031068031188031068031188031078031168031048011038031168031038021048031148031048031048031128031048051048041088041048071048141048091048121048111048101048131048081048151058041058171058021058201088231068261028441010016012011950950950950650011

Em retrospectiva, neste ponto, eu poderia ter feito esse passo antes de juntar tudo, mas como você vive e aprende. Fazemos algo inteligente que é fazer a contagem de cada grupo (2 dígitos) e adicionamos 31. Como todos eles são <96, o número resultante é o valor ASCII para um caractere imprimível (32 a 126). Dando-nos conta de:

|7%7%% ) %%$!)!$%#")"#%#")"#%"#)#"%"$'$"%"%%%"%"1"%"1"%"1"&"/"# ""/""!#"-"#"#"+"#$##'##&#-#(#+#*#)#,#'#.$#$0$!$3'6%9!K    ~~~~` 

Depois de um pouco de reformulação no MATLAB para torná-lo mais favorável à decodificação e também escapar 'caracteres com'' (caso contrário, o MATLAB divide literais de strings por lá), ficamos com a string inteligente:

|871%871%8%1 8)1 8%1%8$1!8)1!8$1%8#1"8)1"8#1%8#1"8)1"8#1%8"1#8)1#8"1%8"1$8''1$8"1%8"1%8%1%8"1%8"118"1%8"118"1%8"118"1&8"1/8"1#8 1"8"1/8"1"8!1#8"1-8"1#8"1#8"1+8"1#8$1#8#1''8#1#8&1#8-1#8(1#8+1#8*1#8)1#8,1#8''1#8.1$8#1$801$8!1$831''861%891!8K1 0 6 2 1~0~0~0~0`0 1

Essa é a raiz do código. No código, tudo o que faço é remodelar a matriz em uma sequência 2D com 128 pares de caracteres. Para cada par, o primeiro caractere 31 subtraiu e, em seguida, o segundo caractere é exibido tantas vezes.

O resultado é o primo original:

888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888111111111111111111111111888888111111111111111111111111888888111111811111111118111111888888111118811111111118811111888888111188811111111118881111888888111188811111111118881111888888111888811111111118888111888888111888881111111188888111888888111888888111111888888111888888111888888888888888888111888888111888888888888888888111888888111888888888888888888111888888811188888888888888881118888188811188888888888888881118881188881118888888888888811188881118888111888888888888111888811111888811118888888811118888111111188881111111111111188881111111118888111111111111888811111111111888811111111118888111111111111188881111111188881111111111111118888811118888811111111111111111888881188888111111111111111111118888888811111111111111111111111888888111111111111111111111111118811111111111111111111111111111111111111111111062100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001

Edições:

• reorganizei a corda mágica para que eu pudesse me livrar de uma transposição após a remodelação. Salva um byte.

05AB1E , 76 bytes

•ŒÆÿ¹т£Ƶ‘β\,ä¸γλaXë«Š¸þaγG(žÃÇ…»šKþÈ/?`'•20BS20öDg81s∍Ss×J30ôø.∞0D445×621s1J

Experimente online!

Roubou isso de Dennis:

888888888888888811111111111111
888888888888888888111111111111
888888888888888888811111111111
888111111111111888881111111111
888111111111111118888111111111
888111111111111111888811111111
888111111888888111188881111111
888111188888888881118888111111
888111888888888888111888811111
888118888888888888811188881111
888111111188888888811118881111
888111111118888888881111888111
888111111111888888881111888811
888111111111888888881111188811
888111111111888888881111118881

Note que sempre alterna entre 8 e 1, então contei os comprimentos de cada execução (Base 20):

['G', 'E', 'I', 'C', 'J', 'B', '3', 'C', '5', 'A', '3', 'E', '4', '9', '3', 'F', '4', '8', '3', '6', '6', '4', '4', '7', '3', '4', 'A', '3', '4', '6', '3', '3', 'C', '3', '4', '5', '3', '2', 'E', '3', '4', '4', '3', '7', '9', '4', '3', '4', '3', '8', '9', '4', '3', '3', '3', '9', '8', '4', '4', '2', '3', '9', '8', '5', '3', '2', '3', '9', '8', '6', '3', '1']

Juntou tudo e converteu em um número inteiro de base 10:

3954184379309026812828704944878416720438306456270310298603957651230861078960874182787979106461

Comprimiu ainda mais na base-255:

ŒÆÿ¹т£Ƶ‘β\,ä¸γλaXë«Š¸þaγG(žÃÇ…»šKþÈ/?`'

Depois de criar o bit compactado ... Nós apenas precisamos manipulá-lo de volta ao original.

20B                                 # Back to base 20.
   S                                # Each char separate...
    20ö                             # As their base 10 values...
       Dg81s∍                       # Extend '81' to the length of the array.
             Ss×J                   # Push that many 8 or 1's as told by the array.
                 30ôø.∞             # Split by the symmetrical pattern, flip it, mirror.
                       0D445×621s1  # Create the part that doesn't fit into a pattern.
                                  J # Join whole stack together.

Saída final:

88888888888888888888888888888
88888888888888888888888888888
88888888888888888888888888888
88811111111111111111111111888
88811111111111111111111111888
88811111181111111118111111888
88811111881111111118811111888
88811118881111111118881111888
88811118881111111118881111888
88811188881111111118888111888
88811188888111111188888111888
88811188888811111888888111888
88811188888888888888888111888
88811188888888888888888111888
88811188888888888888888111888
88881118888888888888881118888
18881118888888888888881118881
18888111888888888888811188881
11888811188888888888111888811
11188881111888888811118888111
11118888111111111111188881111
11111888811111111111888811111
11111188881111111118888111111
11111118888111111188881111111
11111111888881118888811111111
11111111188888188888111111111
11111111111888888811111111111
11111111111188888111111111111
11111111111111811111111111111
11111111111111111111111111111062100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001

C (gcc) , 277 bytes

Tenho a sensação de que a corda pode ser encurtada de alguma forma.

#define F(c,n)for(c=0;c<n;c++)
i,j,k;r(d,n){F(k,n)printf("%d",d);}f(){r(8,90);F(i,128)F(j,6)r(("8111i8111i8915i8=1=i8?1Mi8?1Mi8@1mi8P1oi8p1pi8pppi8pppi8pppi@opPm?opPMOmp@Omip8@iRpR8a41a4Q81i21@1m11O1O11mR@11id811Qp2111p1111="[i]-49>>j)&1?8:1,1);r(1,42);printf("0621%0446d",1);}

Experimente online!

Perl 5 , 307 bytes

$d=1;print((map{($d^=9)x$_}(93,24,6,24,6,6,1,10,1,6,6,5,2,10,2,5,6,4,3,10,3,4,6,4,3,10,3,4,6,3,4,10,4,3,6,3,5,8,5,3,6,3,6,6,6,3,6,3,18,3,6,3,18,3,6,3,18,3,7,3,16,3,4,1,3,3,16,3,3,2,4,3,14,3,4,3,4,3,12,3,4,5,4,4,8,4,4,7,4,14,4,9,4,12,4,11,4,10,4,13,4,8,4,15,5,4,5,17,5,2,5,20,8,23,6,26,2,44)),0,621,0 x445,1)

Experimente online!

Chiclete , 88 bytes

00000000: edc9 310a 0250 10c4 d02b fdb1 90dc ff64  ..1..P...+.....d
00000010: 96c1 80a2 8885 60aa d97d 7cb3 3de8 75c5  ......`..}|.=.u.
00000020: 37ab 820a 51ee 9537 942a 55c4 aaec 76b4  7...Q..7.*U...v.
00000030: cfb5 1cdc 33dd 908b ac1c 74a0 894e 03c8  ....3.....t..N..
00000040: 11cc 99ab 9c1d c661 32c5 bad6 8aad 96d2  .......a2.......
00000050: b95e 76fe fd6e bb01                      .^v..n..

Experimente online!

Ruby , 194 bytes

$><<?8+"~:(:((#,#(('$,$'(&%,%&(&%,%&(%&,&%(%'*'%(%(((%(%4%(%4%(%4%)%2%&#%%2%%$&%0%&%&%.%&'&&*&&)&0&+&.&-&,&/&*&1'&'3'$'6*9(<$N".bytes.reduce(""){|s,x|s+(s[-1]==?8??1:?8)*(x-34)}+"0621"+?0*445+?1

A parte superior é codificada em RLE, o restante é simplesmente codificado.

Experimente online!

Kotlin , 339 bytes

val s="8J188J1888138<13881887148<14871886158<15861886158<15861885168<16851885178:178518851888188518851D8518851D8518851D8519851B85168315851B85158416851@85168516851>85168716861:861689168@168;168>168=168<168?168:168A1786178C1784178F1:8I188L148^130363231ǯ031"
fun x()=(0..s.length-1 step 2).map{i->(1..(s[i].toInt()-50)).map{print(s[i+1])}}

Experimente online!

CJam ( 108 81 bytes)

"u{èl>`#ö^½³ó!;kMðSÀËndEyvY3ÉÊÅBà#®"256bFbee{)*~}%"81"f=15/_Wf%zT6Y446,:!1

Demonstração online

No caso de codificação de caracteres atrapalhar o acima, aqui está codificado em xxd:

0000000: 2275 1e7b e86c 3e60  8d23 80f6 5ebd b3f3  "u.{.l>`.#..^...
0000010: 213b 968d 6b4d f053  c0cb 6e64 1c45 7976  !;..kM.S..nd.Eyv
0000020: 5933 c9ca 8dc5 42e0  23ae 2232 3536 6246  Y3....B.#."256bF
0000030: 6265 657b 292a 7e7d  2522 3831 2266 3d31  bee{)*~}%"81"f=1
0000040: 352f 5f57 6625 7a54  3659 3434 362c 3a21  5/_Wf%zT6Y446,:!
0000050: 31                                        1

A execução inicial de 8s e 1s é dividida na metade esquerda e no comprimento da execução codificado como apenas os comprimentos das execuções alternadas. Execuções de mais de 24 são divididas em execuções de no máximo 24, separadas por execuções de 0, para que os comprimentos possam ser codificados na base 25 e depois na codificação base 256 para compactá-los.

JavaScript (ES2017), 287 bytes

_=>"00000000000000000027wr2027wr2027a9ko261b7c23jerc23jerc1yjm0o1y8coo1y2ou01xx5q01xx5q01xx5q00yykxc9ull699d4au9dk75xffo1v2fgptj4fh8jrj3hhwvgfhmlev3hour5rhq24n3hqytj3hr4hdrhr8ykfhra0hr".replace(/.{6}/g,n=>parseInt(n,36).toString(2).replace(/0/g,8).padStart(30,8))+0+621+"0".repeat(445)+1

Usa uma abordagem ligeiramente diferente para a resposta de @icrieverytim . -10 bytes graças à sugestão de @Shaggy de usar em replacevez de match!

f=
_=>"00000000000000000027wr2027wr2027a9ko261b7c23jerc23jerc1yjm0o1y8coo1y2ou01xx5q01xx5q01xx5q00yykxc9ull699d4au9dk75xffo1v2fgptj4fh8jrj3hhwvgfhmlev3hour5rhq24n3hqytj3hr4hdrhr8ykfhra0hr".replace(/.{6}/g,n=>parseInt(n,36).toString(2).replace(/0/g,8).padStart(30,8))+0+621+"0".repeat(445)+1
;
p.innerHTML=f()

pre{word-wrap:break-word;white-space:normal}

<pre id=p></pre>

/// , 260 bytes

/;/88%//:/1&13%13"//9/\/\///7/"1#95/!!!!94/%""93/8889-/000009,/11#9'/###9&/#88"9%/"""9#/389"/1119!/-----0/'''''''##8%4#;4&"8%18""&11;188"1::1&#%1#"&#8"",8"&&"&&'&&'&&'&#3"'#"#13"'#"3,"##&#"#"'"#",7#7"7%",%#%"#%,%1#%7"",4#8784,8,8%%,#%%",;411;%%41106215555!0001

Experimente online!

Nada terrivelmente interessante, apenas alguma compressão.

Mathematica, 192 bytes

Uncompress["1:eJxTTMoP8nRjZWCwoCUwxAGIl0VSZIEhi2wEXAgma4Eqa0GCrAW6rAW6rAWyJKYsulPRGGhBRLksNmmYy/HJonkOXStWaeTwgTGQ5JADD4mJTQRdGo2PysUwC1kA0yJDFPdgJjWoKHZJNB/hlMYhaYiaMgkDAzMjQ4NRMHSBIQDgQA6C"]

Veja: http://reference.wolfram.com/language/ref/Compress.html

Python 2 , 191 190 188 bytes

s='0621'+'0'*445+'1'
a=1
for c in'L":&7(4%"%1%$%/$($-$*$+$,$)$.$\'$$($$%$#,#$#$#.#$"##0##!$#0#\'#2#&#2#&#2#&#&&&#&#%(%#&#$*$#&$#*#$&$#*#$&%"*"%&&!*!&&8&8}':s=`a`*(ord(c)-32)+s;a^=9
print s

Experimente online!

O mesmo princípio da minha resposta aqui