Salida del PPCG Prime

69

Este es el PPCG Prime

624 dígitos de largo

777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777111111111111111111111111111111111111111111111111111111111111111111111111111111188888888118888888811188888811188888811188111118818811111881881111881881111881188111118818811111881881111111881111111188888888118888888811881111111881118888188111111118811111111881111111881111881188111111118811111111881111881881111881188111111118811111111188888811188888811111111111111111111111111111111111111111111111111111111111111111111111111111111333333333333333333333333333333333333333



Si dividimos cada 39 dígitos obtenemos

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

Su tarea es generar el PPCG-Prime

Este es codegolf. El código más corto en bytes gana.

Si ingresa el PPCG-Prime en la función de Mathematica a continuación, obtendrá este resultado 

ArrayPlot@Partition[IntegerDigits@#,39]&

ingrese la descripción de la imagen aquí

code-golf  kolmogorov-complexity  primes 
37
¿Cómo demonios encontraste esto?
— Stewie Griffin
55
@StewieGriffin La probabilidad promedio de que un número nsea ​​primo es proporcional a 1/log(n), que de todos modos no es muy pequeña. Solo verifica muchos números hasta que sea primo.
— user202729
2
Los comentarios no son para discusión extendida; Esta conversación se ha movido al chat .
— Dennis
1
@ user202729 log(n)se trata 1436.6en este caso.
— Jeppe Stig Nielsen
3
@Fabian No creo que este método sea eficiente ... Para un Prime tan grande (624 dígitos), el número que está pidiendo tiene 621 dígitos (y es aún más difícil de jugar), a menos que sea el 10 ^ 621 ¡¡¡principal!!! Si desea encontrar su número, aquí hay una aproximación simple x/logxde Gauss

Respuestas:

22

Jalea , 55 54 52 47 46 bytes

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

Hay enfoques más intrincados en el historial de revisiones, pero este simple los supera a todos.

Pruébalo en línea!

Cómo funciona

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

Este es un literal numérico, codificado en la base biyectiva 250, donde los dígitos se toman de la página de códigos de Jelly. El argumento de la cadena (izquierda) y el valor de retorno se establecen en el entero codificado,
n: = 0x21871c77d7d7af6fafafeff0c37f72ff7fbfbdbfdfef5edfeff8e3 .

“¿mŻ“p’

Un literal similar al anterior, pero el segundo “separa dos enteros codificados. El valor de retorno se reemplaza con la matriz codificada, [777711, 113] .

Dx39

Dconvierte el valor de retorno a decimal ( [[7, 7, 7, 7, 1, 1], [1, 1, 3]] ), luego x39repite cada entero / dígito individual en el resultado 39 veces. Esto produce un par de matrices, que contienen los dígitos antes y después del texto alto de 7 caracteres, respectivamente. Vamos a llamar a esta matriz A .

jB

Primero, Bconvierte el argumento (izquierdo) n en binario. Esto produce los dígitos que forman el texto alto de 7 caracteres, donde cada 88 ha sido reemplazado por 0 .

Luego, june la matriz A , utilizando la matriz binaria como separador.

o88

Esto realiza un OR lógico con 88 , reemplazando cada 0 con 88 .

V

Tenemos los dígitos correctos ahora, pero en una matriz de 7 's, 1 ' s, 88 's y 3 ' s. Vimplícitamente convierte esta matriz en una cadena y luego la evalúa, produciendo un solo entero.

— Dennis
fuente
6

Chicle , 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..

Pruébalo en línea!

— ovs
fuente
6

SOGL V0.12 , 52 51 bytes

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

corbatas ¡chicle!
tenga en cuenta que esta respuesta contiene una pestaña

Pruébalo aquí!

Intenta guardar bytes reutilizando la misma cadena para ambos P s.

Explicación:

...‘...‘²Κ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

Los números allí se guardan a partir del original, comenzando en la parte inferior izquierda, subiendo, luego 1 a la derecha y abajo, luego arriba, etc.

Una versión de compresión simple de 52 bytes:

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

Pruébalo aquí!

— dzaima
fuente
No estoy seguro de si lo que has publicado es el código correcto en absoluto ...
— Erik the Outgolfer
1
¿Cómo se ...‘obtienen esos números?
— Pureferret
1
@Pureferret Compresión de cuerdas.
— totalmente humano
@totallyhuman, entonces, ¿cómo 'codifica' / comprime esas cadenas ...‘?
— Pureferret
@dzaima No creo que eso realmente me ayude a entender, desafortunadamente. Ingresar la primera parte que codifica CGen esa herramienta no da ...‘lugar a ninguna parte de esa herramienta.
— Pureferret
4

Mathematica, 107 bytes

Uncompress@"1:eJxTTMoP8ixgYmAwH8TAkLrAAgqQWYbYGFDVGCxkBh5lCDNwWIqqDCyGrAGDhWEpFmXY3IaiDItPqQqMiQMA+yaAoA=="


Pruébalo en línea!

— J42161217
fuente
Corrígeme si me equivoco, pero ¿es esa una solución REPL? Esa no parece ser una función (que supongo que podría solucionar con una sola &al final).
— numbermaniac
Esto no se supone que sea una función. este código solo genera el PPCG prime, tal como lo solicitó el OP
— J42161217
4

CJam, ASCII, 61

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

Pruébalo en línea

Añadir ]s39/N*para un buen envoltorio.

Explicación:

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
fuente
4

C, 519 427 414 396 377 bytes

Gracias a Tas, Felix Palmen y 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 su interés, aquí hay una versión más larga y fácil de leer:

#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
fuente
1
Puede bajar mucho (~ 450ish) simplemente imprimiendo los 1s y 8s como están, y tener una definición para el 7, 3 y 1
— Tas
@Keyu Gan: Estoy compilando una versión actual de GCC (7.2.0-debian11), que permite esto durante un par de años. No estoy muy seguro de si la sintaxis está quizás en uno de los estándares C más nuevos.
— xanoetux
2
@Keyu Gan: está permitido en C99 y C11.
— xanoetux
1
— Felix Palmen
Esta versión es muy complicada. Al menos lo entiendo; Gracias.
— 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);}

Pruébalo en línea!

Créditos

  • -10 bytes gracias a aditsu!
— Olivier Grégoire
fuente
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
Buena captura, el doble 88, gracias!
— 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

Pruébalo en línea!

— ovs
fuente
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
fuente
1
Ahorre dos bytes cambiando echo|acd|
— stevefestl
Gracias, sabía que había algo más corto, pero no podía recordarlo
— Schnaader
Además, (1,1,156) dose puede acortar a(1,1,156)do
— stevefestl
2

Javascript (ES6), 187181 bytes

-6 bytes gracias 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)

Enfoque super simple; probablemente podría jugarse un poco más.

Explicación

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

Fragmento de código de ejemplo (con algún código auxiliar para agregar saltos de línea en la salida)

Mostrar fragmento de código

— Herman L
fuente
Puede guardar algunos bytes si se define una función de ayuda rcomo r=s=>s[0].repeat(39)y luego reemplace a, by kcon r`7` etc probarlo en línea! .
— Justin Mariner el
2

C (gcc) , 269 267 bytes

función, utiliza RLE simple.

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);}

Pruébalo en línea!

— Felix Palmen
fuente
Sugerir en L"'OP\x9c"lugar dex
— ceilingcat
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);}

Pruébalo en línea!

Contiene algunos no imprimibles, el literal de cadena es "ww\x11dfFdfFDfFDfFDFDDFFDDFFDddDDFdDDddDDddDDDdDDDDffDffDFDDDFDfdDDDDFDDDdDDDdDDFdDDDDFDDDdDDFFDdDFDDDdDDDDdfDdfD\x11\x03".

— Lynn
fuente
1

Jalea , 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¤Ḍ

Pruébalo en línea!

-12 bytes gracias al usuario202729

— Hiperneutrino
fuente
88 bytes: TIO ( “can separates a list of strings inside a string literal)
— usuario202729
¿Qué hora es en tu país? ¿Por qué estás despierto ahora?
— user202729
@ user202729 Ah, claro, gracias. Y estoy en UTC-4, hice una estupidez y tuve que quedarme despierto hasta tarde, así que tuve ganas de hacer un desafío antes de irme a dormir ya que esto se volvió a abrir. Puedo elaborar en el chat si quieres: P
— HyperNeutrino
1

Python 2 , 309 158 155 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

Pruébalo en línea!

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

Pruébalo en línea!

— TFeld
fuente
1

Jalea , 85 bytes

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

Pruébalo en línea!

Basado en el enfoque de Dennis para el desafío Trinity Hall, menos la simetría, más los 7s iniciales y finales 3.

— Erik el Outgolfer
fuente
3
Dennis abordó este desafío de manera diferente porque es diferente. ¡Creo que te han superado!
@JoseZaman Hizo 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

Pruébalo en línea!

Multiplicación de cadenas, concatenación y reemplazos. PowerShell no tiene base 36 o similar, por lo que las opciones de compresión de gran número son limitadas. Puede haber una mejor manera de "comprimir" la parte media, todavía estoy revisando eso.

— AdmBorkBork
fuente
1

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

Primero exporta el número a un archivo GZIP. Este archivo, llamado "o" sin extensión tendrá exactamente 71 bytes, lo que cuenta para el total. Por defecto, irá a su $TemporaryDirectory. Omitir dígitos para facilitar la lectura.

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

Entonces

"o"~Import~"GZIP"

reconstruirá el número. El nombre del archivo es un byte, de ahí viene el +1.

Pruébalo en línea!

— Kelly Lowder
fuente
1

Ruby, 109 bytes

El script llama Zlib.inflatepara descomprimir el número. Necesita al menos Ruby 1.9.3. Contiene bytes no imprimibles, por lo que no puedo pegarlo aquí.

Pego la salida 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-!

Si tiene unvis (1), ejecute unvis prime-inflate.vis > prime-inflate.rbpara restaurar el script de 109 bytes. O puede decodificar la Base64, a continuación, con ruby -e 'print *STDIN.read.unpack(?m)' < prime-inflate.b64 > prime-inflate.rb.

cmVxdWlyZSd6bGliJwpwdXRzIFpsaWIuaW5mbGF0ZSBEQVRBLnJlYWQKX19F
TkRfXwp42jM3H7zAkLrAAgqQWYbYGFDVGCxkBh5lCDNwWIqqDCyGrAGDhWEp
FmXY3IaiDItPqQqMiQMAEPB+oQ==

Llamo Zlib.inflateasí que no necesito diseñar y desarrollar mi propio algoritmo de descompresión. Utilizo DATAcon __END__porque la cadena comprimida no es válida UTF-8. El código de Ruby debe ser ASCII válido (en Ruby 1.9.x) o UTF-8 (de Ruby 2.0) o debe tener un comentario mágico #coding:binarypara cambiar la codificación, pero Ruby no comprueba la codificación después __END__.

— kernigh
fuente
1

6502 código máquina (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

Demostración en línea

Uso: sys49152

  • -20 bytes con una mejor implementación del mismo método y tablas de datos para bloques grandes también.

Explicación

Esto también usa las longitudes de las secuencias 1y 8en la parte media; Como todos son más cortos que 16, dos de ellos están codificados por byte.

Lista de desmontaje 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
fuente
1

C (gcc) , 188 187 185 bytes

-1 gracias a JonathanFrech.

-2 gracias 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);}

Pruébalo en línea!

— gastropner
fuente
2
Bienvenido a PPCG, buena primera respuesta!
— ovs
Creo que puede cambiar su cadena para llegar a una cadena que no necesita escapar de una barra invertida, lo que resulta en 187 bytes .
— Jonathan Frech
@ JonathanFrech ¡Ah, agradable!
— Gastropner
@ceilingcat Buena captura!
— Gastropner
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"<

Pruébalo en línea!

— ItsJ0el
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.