Saída do PPCG Prime

69

Este é o PPCG Prime

624 dígitos

777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777111111111111111111111111111111111111111111111111111111111111111111111111111111188888888118888888811188888811188888811188111118818811111881881111881881111881188111118818811111881881111111881111111188888888118888888811881111111881118888188111111118811111111881111111881111881188111111118811111111881111881881111881188111111118811111111188888811188888811111111111111111111111111111111111111111111111111111111111111111111111111111111333333333333333333333333333333333333333



Se dividirmos a cada 39 dígitos, obtemos

777777777777777777777777777777777777777
777777777777777777777777777777777777777
777777777777777777777777777777777777777
777777777777777777777777777777777777777
111111111111111111111111111111111111111
111111111111111111111111111111111111111
188888888118888888811188888811188888811
188111118818811111881881111881881111881
188111118818811111881881111111881111111
188888888118888888811881111111881118888
188111111118811111111881111111881111881
188111111118811111111881111881881111881
188111111118811111111188888811188888811
111111111111111111111111111111111111111
111111111111111111111111111111111111111
333333333333333333333333333333333333333

Sua tarefa é produzir o PPCG-Prime

Este é o codegolf . O código mais curto em bytes vence.

Se você inserir o PPCG-Prime na função Mathematica abaixo, obterá este resultado 

ArrayPlot@Partition[IntegerDigits@#,39]&

insira a descrição da imagem aqui

code-golf  kolmogorov-complexity  primes 
37
Como diabos você encontrou isso?
— Stewie Griffin
5
@StewieGriffin A probabilidade média de um número nser primo é proporcional a 1/log(n), o que não é muito pequeno. Basta verificar muitos números até que seja primo.
— user202729
2
Comentários não são para discussão prolongada; esta conversa foi movida para o bate-papo .
— Dennis
11
@ user202729 log(n)é sobre 1436.6neste caso.
— Jeppe Stig Nielsen
3
@Fabian Eu não acho que esse método seria eficiente ... Para um Prime deste tamanho (624 dígitos), o número que você está perguntando tem 621 dígitos (e é ainda mais difícil jogar golfe), a menos que este seja o 10 ^ 621º prime !!! Se você quiser encontrar o seu número, aqui é uma aproximação simples x/logxpor Gauss

Respostas:

22

Geléia , 55 54 52 47 46 bytes

“=÷¡v⁺ʋiṂYR¤"bİɲ}Ñ1Ṇ⁴ẠV⁹yȥGẇ’“¿mŻ“p’Dx39jBo88V

Existem abordagens mais complicadas no histórico de revisões, mas essa simples supera todas elas.

Experimente online!

Como funciona

“=÷¡v⁺ʋiṂYR¤"bİɲ}Ñ1Ṇ⁴ẠV⁹yȥGẇ’

Este é um literal numérico, codificado na base bijetiva 250, onde os dígitos são retirados da página de código de Jelly. O argumento da cadeia (à esquerda) e o valor de retorno são definidos como o número inteiro codificado,
n: = 0x21871c77d7d7af6fafafeff0c37f72ff7fbfbdbfdfef5edfeff8e3 .

“¿mŻ“p’

Um literal semelhante ao anterior, mas o segundo “separa dois números inteiros codificados. O valor retornado é substituído pelo array codificado, [777711, 113] .

Dx39

Dconverte o valor de retorno em decimal ( [[7, 7, 7, 7, 1, 1], [1, 1, 3]] ) e depois x39repete cada número inteiro / dígito individual no resultado 39 vezes. Isso gera um par de matrizes, que contém os dígitos antes e depois do texto alto de 7 caracteres, respectivamente. Vamos chamar essa matriz A .

jB

Primeiro, Bconverte o argumento (esquerdo) n em binário. Isso gera os dígitos que formam o texto alto de 7 caracteres, onde cada 88 foi substituído por 0 .

Em seguida, jingressa na matriz A , usando a matriz binária como separador.

o88

Isso executa OR lógico com 88 , substituindo cada 0 por 88 .

V

Agora, temos os dígitos corretos, mas em uma matriz de 7 , 1 , 88 e 3 . Vimplicitamente transforma essa matriz em uma sequência e a avalia, produzindo um único número inteiro.

— Dennis
fonte
6

Chiclete , 51 bytes

00000000: 331f c4c0 90ba c002 0a90 5986 d818 50d5  3.........Y...P.
00000010: 282c 3406 6e65 5036 1e4b 9195 8109 649d  (,4.neP6.K....d.
00000020: 5858 1896 4279 68b2 f895 61fa 94ca c098  XX..Byh...a.....
00000030: 3800 00                                  8..

Experimente online!

— ovs
fonte
6

SOGL V0.12 , 52 51 bytes

≡=vā⁷H↕↕jΥ_Ν↑∆∫▲pΖo	‘θδžΟwd╬2n?q[‘²Κ7n⌡"α¼■╤ģ⅞¹‘¹H∑

gravatas chiclete!
note que esta resposta contém uma guia

Experimente aqui!

Tenta salvar bytes reutilizando a mesma sequência para os dois P.

Explicação:

...‘...‘²Κ7n⌡"..‘¹H∑  compressed strings replaced with ellipses to shorten the width
...‘                  pushes "1111111188888188888888111118811111881111188111118881118818111811111111188888188888888111118811111881111188118118888818818881811118111" - CG
    ...‘              pushes "1111111888888888888881118118111811811181181118118111811811188881111881" - P
        ²             join with itself - double the P
         Κ            reverse add - prepend the PP to CG
          7n          split to line lengths of 7
            ⌡         for each
             "..‘       push "311ŗ117777" with ŗ replaced with the ToS - current item looping over
                 ¹    wrap the results tn an array
                  H   rotate it counter-clockwise
                   ∑  join to a single string

Os números são salvos a partir do original, começando no canto inferior esquerdo, subindo, depois 1 à direita e para baixo, depois para cima, ect.

Uma versão de compressão simples de 52 bytes:

#⅓→9E■Ν►1&⅝θ⅞%øøμ←N═]y)u⅝↓$A○░(ZF16Φ⅓Mč▓d⅛Hι‼∑υnη▲Z‘

Experimente aqui!

— dzaima
fonte
Não tenho certeza se o que você postou é o código correto ...
— Erik the Outgolfer
11
como ...‘consegue esses números?
— Pureferret
11
@Pureferret Compactação de strings.
— totallyhuman
@totallyhuman então como ele 'codifica' / comprime essas strings ...‘?
— Pureferret
@ Dzaima Eu não acho que isso realmente me ajude a entender, infelizmente. A inserção da primeira parte que codifica a CGferramenta não é ...‘exibida em nenhuma parte dessa ferramenta.
— Pureferret
4

Mathematica, 107 bytes

Uncompress@"1:eJxTTMoP8ixgYmAwH8TAkLrAAgqQWYbYGFDVGCxkBh5lCDNwWIqqDCyGrAGDhWEpFmXY3IaiDItPqQqMiQMA+yaAoA=="


Experimente online!

— J42161217
fonte
Corrija-me se estiver errado, mas essa é uma solução somente para REPL? Isso não parece ser uma função (que eu acho que você poderia consertar com uma única &no final).
— Numbermaniac #
isso não deveria ser uma função. este código apenas saídas do primeiro PPCG, assim como o OP perguntou
— J42161217
4

CJam, ASCII, 61

Hs78f*~_@"'hfv;HH`>O4RU(_o^.U)9q&-1iadr`4tk"90b2b88fe|1$'339*

Experimente online

Anexar ]s39/N*para uma boa embalagem.

Explicação:

Hs         generate "17" (H=17)
78f*       repeat each character 78 times, getting an array of 2 strings
~_         dump the 2 strings on the stack, and duplicate the '7's
@          move the '1's to the top of the stack (first 6 lines done so far)
"…"90b     convert that string from base 90 (treating characters as numbers)
2b         convert the resulting number to base 2,
            obtaining a bit map for the "PPCG" part, with 1 for "1" and 0 for "88"
88fe|      replace (boolean OR) all the zeros with 88
1$         copy the string of 78 '1's
'339*      repeat '3' 39 times
— aditsu
fonte
4

C, 519 427 414 396 377 bytes

Agradecimentos a Tas, Felix Palmen e Lynn.

#define p(n,l)for(i=40*l;i;)putchar(--i%40?n+48:10);
f(i){p(7,4)p(1,2)puts("188888888118888888811188888811188888811\n188111118818811111881881111881881111881\n188111118818811111881881111111881111111\n188888888118888888811881111111881118888\n188111111118811111111881111111881111881\n188111111118811111111881111881881111881\n188111111118811111111188888811188888811");p(1,2)p(3,1)}

Para seu interesse, aqui está uma versão mais longa e fácil de ler:

#define p(n,l) for(i=40*l;i;) putchar(--i%40?n+48:10);
f(i) {
    p(7,4)
    p(1,2)
    puts("188888888118888888811188888811188888811\n\
       188111118818811111881881111881881111881\n\
       188111118818811111881881111111881111111\n\
       188888888118888888811881111111881118888\n\
       188111111118811111111881111111881111881\n\
       188111111118811111111881111881881111881\n\
       188111111118811111111188888811188888811");
    p(1,2)
    p(3,1)
}
— xanoetux
fonte
11
Você pode ficar muito mais baixo (~ 450ish) simplesmente imprimindo os 1s e 8s como estão e tendo uma definição para os 7, 3 e 1
— Tas
@ Keyey Gan: Estou compilando com uma versão atual do GCC (7.2.0-debian11), que permite isso por alguns anos. Não tenho certeza se a sintaxe talvez esteja em um dos mais recentes padrões C.
— Xanoetux 24/10/19
2
@Keyu Gan: É permitido em C99 e C11.
— Xanoetux 24/10
11
— Felix Palmen
Esta versão é muito complicada. Pelo menos eu entendo; obrigado.
— Xanoetux
4

Java (OpenJDK 8) , 165 bytes

n->{for(int i=0;++i<566;)System.out.print(i<157?7:i>526?3:i<236|i>446||new java.math.BigInteger("vnku5g6l0zenpa1kydel5rxw162k4fk4xapa154o",36).testBit(446-i)?1:88);}

Experimente online!

Créditos

  • -10 bytes graças ao aditsu!
— Olivier Grégoire
fonte
165:n->{for(int i=0;++i<566;)System.out.print(i<157?7:i>526?3:i<236|i>446||new java.math.BigInteger("vnku5g6l0zenpa1kydel5rxw162k4fk4xapa154o",36).testBit(446-i)?1:88);}
— aditsu 25/10
Boa captura, o dobro 88, obrigado!
— Olivier Grégoire
2

Retina , 129 bytes


h155b78i7b1i7b2i5b2i5b2!4!!4!""1!4!!4!!6#i7b1i7b1!6!2i3b##!6"1##""1#!8i5b2i5b79d38
#
!7
"
!3!
!
i1b
\d+
$*
+`(\D)1
$1$1
1

T`l`d

Experimente online!

— ovs
fonte
2

Lote, 364 335 333 bytes

@set a=888888&set b=1111111111111&set e=1881111&set d=1%e%&set f=333333333&for /L %%x in (1,1,156) do @cd|set/p=7
@echo %b%%b%%b%%b%%b%%b%1%a%8811%a%88111%a%111%a%1%d%188%e%188%e%88%e%88%d%188%e%188%e%1%d%1111%a%8811%a%88%d%111881118888%e%11%d%11%d%1%d%88%d%11%d%11%d%88%e%88%d%11%d%11111%a%111%a%%b%%b%%b%%b%%b%%b%11%f%%f%%f%%f%333
— schnaader
fonte
11
Salve dois bytes alterando echo|paracd|
— stevefestl
Obrigado, eu sabia que havia algo mais curto, mas não conseguia se lembrar
— schnaader
Além disso, (1,1,156) dopode ser encurtado para(1,1,156)do
— stevefestl
2

JavaScript (ES6), 187 181 bytes

-6 bytes graças a @JustinMariner

r=s=>s[0].repeat(39),a=r`7`,b=r`1`,i="8888881",c=188+i,d=11+i,j="188111",e=j+1188,f=j+188,g=j+111,h=g+1,k=r`3`
z=>"aaaabbccdd1eeff1eeghccgj8888hhgf1hhff1hhdd1bbk".replace(/./g,eval)

Abordagem super simples; provavelmente poderia ser jogado um pouco mais.

Explicação

r=s=>s[0].repeat(39),                               // helper function to repeat character
a=r`7`,b=r`1`,i="8888881",c=188+i,d=11+i,j="188111",// Set the variables (a-k) to different
e=j+1188,f=j+188,g=j+111,h=g+1,k=r`3`               // parts of the prime       

_=>"aaaabbccdd1eeff1eeghccgj8888hhgf1hhff1hhdd1bbk" // Replace all letters in the string
    .replace(/./g,eval)                             // with the value of the variable

Exemplo de trecho de código (com algum código auxiliar para adicionar quebras de linha na saída)

Mostrar snippet de código

— Herman L
fonte
Você pode salvar alguns bytes se você definir uma função auxiliar rcomo r=s=>s[0].repeat(39)e em seguida, substituir a, be kcom r`7` etc. Experimente online! .
— Justin Mariner
2

C (GCC) , 269 267 bytes

função, usa RLE simples.

x[]={39,79,80,156};k;f(i){for(char*c="d7b1882188316831683128512811285128112841281128412821285128112851281128712881882188212871283148112881288128712841282128812881284128112841282128812891683168c1a3";i=*c++;++c)for(i=i<97?i-48:x[i-97];i--;++k%39||puts(""))putchar(*c);}

Experimente online!

— Felix Palmen
fonte
Sugerir em L"'OP\x9c"vez dex
— ceilingcat 6/09/19
2

C (gcc) , 224 bytes

f(i,j,c){for(i=0;c="wwdfFdfFDfFDfFDFDDFFDDFFDddDDFdDDddDDddDDDdDDDDffDffDFDDDFDfdDDDDFDDDdDDDdDDFdDDDDFDDDdDDFFDdDFDDDdDDDDdfDdfD"[i/2]>>i++%2*4&15;c-6?putchar(c-4?c+48:49):printf("88"))for(j=0;j++<c%2*38;)putchar(c+48);}

Experimente online!

Contém alguns imprimíveis, a string literal é "ww\x11dfFdfFDfFDfFDFDDFFDDFFDddDDFdDDddDDddDDDdDDDDffDffDFDDDFDfdDDDDFDDDdDDDdDDFdDDDDFDDDdDDFFDdDFDDDdDDDDdfDdfD\x11\x03".

— Lynn
fonte
1

Geléia , 86 bytes

Lẋ@1,8żḣLẋ/€F
7ẋ156;1ẋ78¤©;“½Ẹ^o“2FẒ⁶ġbȥ“¡E⁷£cṿ“t¡ɗḋ“£F¢Xȥ“¡McṾbȥ“¬3Ṭo’DÇ€F¤;®;3rẋ39¤Ḍ

Experimente online!

-12 bytes graças a user202729

— HyperNeutrino
fonte
88 bytes: TIO ( “can separates a list of strings inside a string literal)
— user202729 23/17
Que horas são em seu país? Por que você está acordado agora?
— user202729
@ user202729 Ah, certo, obrigado. E eu estou no UTC-4. Eu fui estúpido e tive que ficar acordado até tarde, então tive vontade de fazer um desafio antes de dormir, pois isso foi reaberto. Eu posso elaborar no chat se você quiser: P
— HyperNeutrino
1

Python 2 , 309 158 155 136 136 135 bytes

x='1'*78
s='7'*156+x
a=1
for c in str(int('109PDKEZ3U32K97KJQVELW8GKXCD42EGEYK715B6HPMPL0H8RU',36)):s+=`a`*int(c);a^=9
print s+x+'3'*39

Experimente online!

Python 2 , 137 bytes

s='7'*156
a=1
for c in'90'*8+str(int('PL6PU5TXIC24LCKIQY50C2LPAIC9TVZEVQGTMM63IHGBBUV1XSA6',36))+'09'*8:s+=`a`*int(c);a^=9
print s+'3'*39

Experimente online!

— TFeld
fonte
1

Geléia , 85 bytes

”7ẋ“ɓ’80“¡Ȯ⁶LÑɓĠ⁶-€Øġ°$¤ṛọḳƓƒṭ⁽@^ḥ⁷Ofạ<e½Ṇż;,RṘ¶ṀḊ+`⁸ⱮḃĿþṛ9.wƑ¡kḟUẎgLLµ’ḃĖŒṙị⁾1839”3ẋ

Experimente online!

Com base na abordagem de Dennis ao desafio do Trinity Hall, menos a simetria, mais os valores iniciais 7e finais 3.

— Erik, o Outgolfer
fonte
3
Dennis abordou esse desafio de maneira diferente porque é diferente. Eu acho que você foi derrotado!
@JoseZaman Ele fez Jelly BTW.
— Erik the Outgolfer
1

PowerShell , 164 bytes

$a='136361616151315131531532513151315215436365213213315454521532545453153254541616';6..2|%{$a=$a-replace$_,(11,88,22,34,3332)[$_-2]};'7'*156+'1'*78+$a+'1'*78+'3'*39

Experimente online!

Multiplicação, concatenação e substituições de cadeias. O PowerShell não possui base 36 ou similar, portanto, as opções de compactação de número grande são limitadas. Pode haver uma maneira melhor de "comprimir" a parte do meio - ainda estou verificando isso.

— AdmBorkBork
fonte
1

Wolfram Language (Mathematica) , 89 (17 + 71 + 1) bytes

Primeiro você exporta o número para um arquivo GZIP. Este arquivo, denominado "o" sem extensão, terá exatamente 71 bytes, o que conta para o total. Por padrão, ele irá para o seu $TemporaryDirectory. Omitindo dígitos para facilitar a leitura.

Export["o",777777...,"GZIP"]

Então

"o"~Import~"GZIP"

irá reconstruir o número. O nome do arquivo é de um byte, e é daí que o +1 vem.

Experimente online!

— Kelly Lowder
fonte
1

Ruby, 109 bytes

O script chama Zlib.inflatepara descompactar o número. Precisa de pelo menos Ruby 1.9.3. Ele contém bytes imprimíveis, então não posso colá-lo aqui.

Eu colo a saída de vis prime-inflate.rb:

require'zlib'
puts Zlib.inflate DATA.read
__END__
x\M-Z37\^_\M-<\M-@\M^P\M-:\M-@\^B
\M^PY\M^F\M-X\^XP\M-U\^X,d\^F\^^e\^H3pX\M^J\M-*\^L,\M^F\M-,\^A\M^C\M^Ea)\^Ve\M-X\M-\\M^F\M-"\^L\M^KO\M-)
\M^L\M^I\^C\^@\^P\M-p~\M-!

Se você tiver unvis (1), execute unvis prime-inflate.vis > prime-inflate.rbpara restaurar o script de 109 bytes. Ou você pode decodificar o Base64, abaixo, com ruby -e 'print *STDIN.read.unpack(?m)' < prime-inflate.b64 > prime-inflate.rb.

cmVxdWlyZSd6bGliJwpwdXRzIFpsaWIuaW5mbGF0ZSBEQVRBLnJlYWQKX19F
TkRfXwp42jM3H7zAkLrAAgqQWYbYGFDVGCxkBh5lCDNwWIqqDCyGrAGDhWEp
FmXY3IaiDItPqQqMiQMAEPB+oQ==

Eu ligo Zlib.inflatepara não precisar projetar e jogar com meu próprio algoritmo de descompressão. Eu uso DATAcom __END__porque a sequência compactada não é válida UTF-8. O código Ruby deve ser ASCII válido (no Ruby 1.9.x) ou UTF-8 (do Ruby 2.0) ou ter um comentário mágico #coding:binarypara alterar a codificação, mas o Ruby não verifica a codificação depois __END__.

— Kernigh
fonte
1

Código da máquina 6502 (C64), 142 122 bytes

00 C0 A9 27 85 FB A2 00 86 FC A2 04 CA 10 01 60 BC 70 C0 BD 74 C0 20 D2 FF C6
FB D0 0B 48 A9 27 85 FB A9 0D 20 D2 FF 68 88 D0 EB E0 02 D0 DD 48 A5 FC 4A A8
B9 4A C0 90 04 4A 4A 4A 4A 29 0F F0 08 E6 FC A8 68 49 09 D0 CD 68 D0 C0 28 38
36 36 52 12 52 12 42 12 42 22 52 12 52 12 72 82 28 28 72 32 14 82 82 72 42 22
82 82 42 12 42 22 82 92 36 06 27 50 4F 9C 33 31 31 37

Demonstração online

Uso: sys49152

  • -20 bytes com melhor implementação do mesmo método e tabelas de dados para blocos grandes também.

Explicação

Isso também usa os comprimentos das seqüências 1e 8na parte do meio; como todos têm menos de 16 anos, dois deles são codificados por byte.

Listagem de desmontagem comentada:

         00 C0        .WORD $C000       ; load address
.C:c000  A9 27        LDA #$27          ; counter for newlines (39)
.C:c002  85 FB        STA $FB
.C:c004  A2 00        LDX #$00          ; index for run-length data
.C:c006  86 FC        STX $FC
.C:c008  A2 04        LDX #$04          ; index for "blocks" (counting down)
.C:c00a   .blockloop:
.C:c00a  CA           DEX
.C:c00b  10 01        BPL .continue     ; block index underflow -> done
.C:c00d  60           RTS
.C:c00e   .continue:
.C:c00e  BC 70 C0     LDY .lseqlens,X   ; load length of next block to Y
.C:c011  BD 74 C0     LDA .chars,X      ; load character of next block to A
.C:c014   .outloop:
.C:c014  20 D2 FF     JSR $FFD2         ; output character
.C:c017  C6 FB        DEC $FB           ; decrement newline counter
.C:c019  D0 0B        BNE .skipnl
.C:c01b  48           PHA               ; newline needed -> save accu
.C:c01c  A9 27        LDA #$27          ; restore newline counter
.C:c01e  85 FB        STA $FB
.C:c020  A9 0D        LDA #$0D          ; load newline character
.C:c022  20 D2 FF     JSR $FFD2         ; output character
.C:c025  68           PLA               ; restore accu
.C:c026   .skipnl:
.C:c026  88           DEY               ; decrement repeat counter
.C:c027  D0 EB        BNE .outloop      ; repeat until 0
.C:c029  E0 02        CPX #$02          ; check for block index of text part
.C:c02b  D0 DD        BNE .blockloop    ; not in text part -> repeat
.C:c02d   .textpart:
.C:c02d  48           PHA               ; save accu
.C:c02e  A5 FC        LDA $FC           ; load index for run-length data
.C:c030  4A           LSR A             ; and shift right
.C:c031  A8           TAY               ; -> to Y register
.C:c032  B9 4A C0     LDA .seqlens,Y    ; load run-length data
.C:c035  90 04        BCC .lownibble    ; carry clear from shift -> low nibble
.C:c037  4A           LSR A             ; shift high nibble into low nibble
.C:c038  4A           LSR A
.C:c039  4A           LSR A
.C:c03a  4A           LSR A
.C:c03b   .lownibble:
.C:c03b  29 0F        AND #$0F          ; mask low nibble
.C:c03d  F0 08        BEQ .textdone     ; run-length zero? then text block done
.C:c03f  E6 FC        INC $FC           ; increment index for run-length data
.C:c041  A8           TAY               ; run-length to y-register
.C:c042  68           PLA               ; restore accu
.C:c043  49 09        EOR #$09          ; toggle between '8' and '1'
.C:c045  D0 CD        BNE .outloop      ; and back to output loop
.C:c047   .textdone:
.C:c047  68           PLA               ; restore accu
.C:c048  D0 C0        BNE .blockloop    ; back to loop for next block
.C:c04a   .seqlens:
.C:c04a  28 38 36 36  .BYTE $28,$38,$36,$36
.C:c04e  52 12 52 12  .BYTE $52,$12,$52,$12
.C:c052  42 12 42 22  .BYTE $42,$12,$42,$22
.C:c056  52 12 52 12  .BYTE $52,$12,$52,$12
.C:c05a  72 82 28 28  .BYTE $52,$82,$28,$28
.C:c05e  72 32 14 82  .BYTE $72,$32,$14,$82
.C:c062  82 72 42 22  .BYTE $82,$72,$42,$22
.C:c066  82 82 42 12  .BYTE $82,$82,$42,$12
.C:c06a  42 22 82 92  .BYTE $42,$22,$82,$92
.C:c06e  36 06        .BYTE $36,$06
.C:c070   .lseqlens:
.C:c070  27 50 4F 9C  .BYTE $27,$50,$4F,$9C
.C:c074   .chars:
.C:c074  33 31 31 37  .BYTE "3117"
— Felix Palmen
fonte
1

C (GCC) , 188 187 185 bytes

-1 graças a JonathanFrech.

-2 graças a ceilingcat.

#define F(c,n)for(c=0;c<n;c++)
i,j,k;r(d,n){F(k,n)printf("%d",d);}f(){r(7,156);r(1,79);F(i,45)F(j,6)r("pdpi8pIa7]R>=4gQ>Q2iPoX2=O4a1=QRJ17QR>=4a1i8p"[i]-49>>j&1?8:1,1);r(1,80);r(3,39);}

Experimente online!

— gastropner
fonte
2
Bem-vindo ao PPCG, boa primeira resposta!
— ovs 7/11
Eu acho que você pode mudar sua string para chegar a uma string que não precisa escapar de uma barra invertida, resultando em 187 bytes .
— Jonathan Frech
@JonathanFrech Ah, que bom!
— Gastropner
@ceilingcat Boa captura!
— Gastropner 21/08/19
0

Befunge-93 , 500 bytes

v F         >20g1-20p
>"3"20g10g`#^_>52*"F"20p30g10g`#v_"^!1"21p30p84*2+1p
^                       p03-1g03<
^>"81118888888811888888881>!"30p84*2+1p52*
^^"8888811188888811"*25"188111118"<>">#7"21p30p57*5p
>*"188111188188111188188111118818"^ $>:#,_@
^25"18811111881881111188188111111"<
>"8888811888888881"25*"1111111881"^
^"88811881111111881118888"*25"188"<
>"1188111111188111111118811111111"^
^"11881"*52"188111111118811111111"<
>"11111881"52*"188111188188111188"^
^"1118811111111188888811188888811"<

Experimente online!

— ItsJ0el
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.