C'est le PPCG Prime

624 chiffres de long

777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777111111111111111111111111111111111111111111111111111111111111111111111111111111188888888118888888811188888811188888811188111118818811111881881111881881111881188111118818811111881881111111881111111188888888118888888811881111111881118888188111111118811111111881111111881111881188111111118811111111881111881881111881188111111118811111111188888811188888811111111111111111111111111111111111111111111111111111111111111111111111111111111333333333333333333333333333333333333333

Si nous divisons tous les 39 chiffres, nous obtenons

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

Votre tâche consiste à sortir le PPCG-Prime

C'est codegolf . Le code le plus court en octets gagne.

Si vous entrez le code PPCG-Prime dans la fonction Mathematica ci-dessous, vous obtenez ce résultat.

ArrayPlot@Partition[IntegerDigits@#,39]&

37

Comment as-tu trouvé ça?

Stewie Griffin

5

@StewieGriffin La probabilité moyenne qu'un nombre nsoit premier est proportionnelle à 1/log(n), ce qui n'est pas très petit, de toute façon. Il suffit de vérifier beaucoup de chiffres jusqu'à ce qu'il soit en prime.

user202729

2

Les commentaires ne sont pas pour une discussion prolongée; cette conversation a été déplacée pour discuter .

Dennis

1

@ user202729 log(n)est 1436.6dans ce cas.

Jeppe Stig Nielsen

3

@Fabian Je ne pense pas que cette méthode serait efficace ... Pour un Prime aussi gros (624 chiffres), le nombre que vous demandez a 621 chiffres (et est encore plus difficile à jouer au golf), à moins que ce ne soit le 10 ^ 621e premier!!! Si vous voulez trouver votre numéro, voici une approximation simple x/logxde Gauss

22

Jelly , 55 54 52 47 46 octets

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

Il existe des approches plus compliquées dans l’historique des révisions, mais cette approche simple les bat toutes.

Essayez-le en ligne!

Comment ça fonctionne

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

Il s'agit d'un littéral numérique, codé dans la base bijective 250, où les chiffres sont extraits de la page de code de Jelly. L'argument (à gauche) de la chaîne et la valeur de retour sont définis sur l'entier codé
n: = 0x21871c77d7d7af6fafafeff0c37f72ff7f7fbfbdbfdfef5edfeff8e3 .

“¿mŻ“p’

Un littéral similaire à celui ci-dessus, mais le second “sépare deux entiers codés. La valeur de retour est remplacée par le tableau codé, [777711, 113] .

Dx39

Dconvertit la valeur renvoyée en valeur décimale ( [[7, 7, 7, 7, 1, 1], [1, 1, 3]] ), puis x39répète chaque nombre entier / chiffre dans le résultat 39 fois. Cela donne une paire de tableaux contenant les chiffres avant et après le texte de 7 caractères, respectivement. Appelons ce tableau A .

jB

D'abord, Bconvertit l'argument (gauche) n en binaire. Cela donne les chiffres qui forment le texte de 7 caractères, où chaque 88 a été remplacé par 0 .

Ensuite, jrejoint le tableau A , en utilisant le tableau binaire comme séparateur.

o88

Ceci effectue un OU logique avec 88 , en remplaçant chaque 0 par 88 .

Nous avons les bons chiffres maintenant, mais dans un tableau de 7 , 1 , 88 et 3 . Vtransforme implicitement ce tableau en chaîne, puis l’évalue, ce qui donne un seul entier.

Dennis
la source

6

Bubblegum , 51 octets

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

Essayez-le en ligne!

ovs
la source

6

SOGL V0.12 , 52 51 octets

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

^{^{cravates bubblegum!}}
notez que cette réponse contient un onglet

Essayez-le ici!

Essaie de sauvegarder des octets en réutilisant la même chaîne pour les deux caractères P.

Explication:

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

Les numéros y sont sauvegardés à partir de l’original en commençant par le bas à gauche, en montant, puis à droite et en bas, puis en haut, etc.

Une version de compression simple de 52 octets:

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

Essayez-le ici!

dzaima
la source

Je ne suis pas sûr si ce que vous avez posté est le bon code du tout ...

Erik the Outgolfer

1

comment ...‘obtenir ces chiffres?

Pureferret

1

@Pureferret Compression de chaîne.

totalement humain

@totallyhuman alors comment fait-il pour "encoder" / compresser ces chaînes ...‘?

Pureferret

@ Dzaima Je ne pense pas que cela m'aide réellement à comprendre, malheureusement. La saisie de la première partie qui code l' CGoutil dans cet outil ne donne rien ...‘dans cet outil.

Pureferret

4

Mathematica, 107 octets

Uncompress@"1:eJxTTMoP8ixgYmAwH8TAkLrAAgqQWYbYGFDVGCxkBh5lCDNwWIqqDCyGrAGDhWEpFmXY3IaiDItPqQqMiQMA+yaAoA=="

Essayez-le en ligne!

J42161217
la source

Corrigez-moi si je me trompe, mais s'agit-il d'une solution reposant uniquement sur REPL? Cela ne semble pas être une fonction (que je suppose que vous pourriez résoudre avec un seul &à la fin).

numbermaniac

ce n'est pas censé être une fonction. ce code ne fait que générer le nombre premier PPCG, comme demandé par l'OP

J42161217 Le

4

CJam, ASCII, 61

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

Essayez-le en ligne

Ajoutez ]s39/N*pour un bel emballage.

Explication:

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
la source

4

C, 519 427 414 396 377 octets

Merci à Tas, Felix Palmen et 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)}

Pour votre intérêt, voici une version plus longue, plus lisible:

#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
la source

1

Vous pouvez obtenir beaucoup plus bas (~ 450 º) en imprimant simplement les 1 et les 8 comme ils sont, et en ayant une définition pour les 7, 3 et 1

Tas

@Keyu Gan: Je compile avec une version actuelle de GCC (7.2.0-debian11), qui le permet pendant quelques années. Je ne suis pas tout à fait sûr si la syntaxe est peut-être dans l'un des nouveaux standards C.

xanoetux

2

@Keyu Gan: Cela est autorisé dans C99 et C11.

xanoetux

1

414 octets

Felix Palmen

Cette version est très délicate. Au moins je le comprends; Merci.

xanoetux

4

Java (OpenJDK 8) , 165 octets

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

Essayez-le en ligne!

Crédits

-10 octets grâce à aditsu!

Olivier Grégoire
la source

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

Belle prise, le double 88, merci!

Olivier Grégoire

2

Retina , 129 octets


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

Essayez-le en ligne!

ovs
la source

2

Lot, 364 335 333 octets

@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
la source

1

Enregistrer deux octets en changeant echo|àcd|

stevefestl

Merci, je savais qu'il y avait quelque chose de plus court, mais je ne m'en souvenais plus

schnaader

Aussi, (1,1,156) dopeut être raccourci à(1,1,156)do

stevefestl

2

Javascript (ES6), 187 181 octets

-6 octets grâce à @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)

Approche super simple; il pourrait probablement être joué au golf un peu plus.

Explication

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

Exemple d'extrait de code (avec un code d'assistance permettant d'ajouter des sauts de ligne dans la sortie)

Afficher l'extrait de code

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)
o.innerText=z().replace(/.{39}/g,"$&\n")

<pre id=o>

Développer l'extrait

Herman L
la source

Vous pouvez enregistrer quelques octets si vous définissez une fonction d'aide rcomme r=s=>s[0].repeat(39)puis remplacer a, bet kavec r`7` etc Essayez - le en ligne! .

Justin Mariner

2

C (gcc) , 269 267 octets

fonction, utilise un simple RLE.

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

Essayez-le en ligne!

Felix Palmen
la source

Suggérez au L"'OP\x9c"lieu dex

ceilingcat

2

C (gcc) , 224 octets

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

Essayez-le en ligne!

Contient des caractères non imprimables, le littéral chaîne est "ww\x11dfFdfFDfFDfFDFDDFFDDFFDddDDFdDDddDDddDDDdDDDDffDffDFDDDFDfdDDDDFDDDdDDDdDDFdDDDDFDDDdDDFFDdDFDDDdDDDDdfDdfD\x11\x03".

Lynn
la source

1

Gelée , 86 octets

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

Essayez-le en ligne!

-12 octets grâce à user202729

HyperNeutrino
la source

88 octets: TIO ( “can separates a list of strings inside a string literal)

utilisateur202729

Quelle heure est-il dans votre pays? Pourquoi es-tu réveillé maintenant?

user202729

@ user202729 Oh oui, merci. Et je suis en UTC-4. J’ai fait une bêtise et je devais rester éveillé tard, j’ai donc eu l’impression de relever un défi avant de me coucher depuis que cela a été rouvert. Je peux élaborer sur le chat si vous le souhaitez: P

HyperNeutrino

1

Python 2 , 309 158 155 136 135 octets

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

Essayez-le en ligne!

Python 2 , 137 octets

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

Essayez-le en ligne!

TFeld
la source

1

Gelée , 85 octets

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

Essayez-le en ligne!

Basé sur l'approche de Dennis au défi de Trinity Hall, moins la symétrie, plus le 7s en tête et le 3s en traînant .

Erik le golfeur
la source

3

Dennis a abordé ce défi différemment parce que c'est un autre. Je pense que vous avez été golfé!

@JoseZaman Il a fait Jelly BTW.

Erik l'Outgolfer

1

PowerShell , 164 octets

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

Essayez-le en ligne!

Multiplication de chaîne, concaténation et remplacements. PowerShell n'a pas de base 36 ou similaire, ce qui limite les options de compression en grand nombre. Il y aurait peut-être un meilleur moyen de "compresser" la partie centrale - je vérifie toujours cela.

AdmBorkBork
la source

1

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

D'abord, vous exportez le numéro dans un fichier GZIP. Ce fichier, nommé "o" sans extension, aura exactement 71 octets, ce qui compte pour le total. Par défaut, il ira à votre $TemporaryDirectory. Omettre les chiffres pour plus de lisibilité.

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

ensuite

"o"~Import~"GZIP"

va reconstruire le nombre. Le nom du fichier est un octet, c’est d’où le +1.

Essayez-le en ligne!

Kelly Lowder
la source

1

Ruby, 109 octets

Le script appelle Zlib.inflatepour décompresser le numéro. Il faut au moins Ruby 1.9.3. Il contient des octets non imprimables, je ne peux donc pas le coller ici.

Je colle la sortie 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 vous avez unvis (1), exécutez-le unvis prime-inflate.vis > prime-inflate.rbpour restaurer le script de 109 octets. Ou vous pouvez décoder la Base64, ci-dessous, avec ruby -e 'print *STDIN.read.unpack(?m)' < prime-inflate.b64 > prime-inflate.rb.

cmVxdWlyZSd6bGliJwpwdXRzIFpsaWIuaW5mbGF0ZSBEQVRBLnJlYWQKX19F
TkRfXwp42jM3H7zAkLrAAgqQWYbYGFDVGCxkBh5lCDNwWIqqDCyGrAGDhWEp
FmXY3IaiDItPqQqMiQMAEPB+oQ==

J'appelle Zlib.inflatedonc je n'ai pas besoin de concevoir et de jouer au golf mon propre algorithme de décompression. J'utilise DATAavec __END__parce que la chaîne compressée n'est pas valide UTF-8. Le code Ruby doit être un code ASCII valide (dans Ruby 1.9.x) ou UTF-8 (à partir de Ruby 2.0) ou avoir un commentaire magique #coding:binarypour changer le codage, mais Ruby ne vérifie pas le codage après __END__.

Kernigh
la source

1

Python 2 , 112 octets

print'7'*156+'1'*78+bin(int('JAOKI5B0O6K9IWDU8P76KDLR0VZMNWQ2WB9D8BOS8',36))[2:].replace('0','88')+'1'*80+'3'*39

Essayez-le en ligne!

Lynn
la source

1

6502 code machine (C64), 142 122 octets

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

Démo en ligne

Usage: sys49152

-20 octets avec une meilleure implémentation de la même méthode et des mêmes tables de données pour les gros blocs.

Explication

Ceci utilise également les longueurs des séquences 1et 8dans la partie centrale; comme ils sont tous inférieurs à 16, deux d'entre eux sont codés par octet.

Liste de désassemblage commentée:

         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
la source

1

C (gcc) , 188 187 185 octets

-1 merci à JonathanFrech.

-2 grâce à 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);}

Essayez-le en ligne!

gastropner
la source

2

Bienvenue sur PPCG, belle première réponse!

Ovs

Je pense que vous pouvez décaler votre chaîne pour obtenir une chaîne qui n'a pas besoin d'échapper une barre oblique inversée, ce qui donne 187 octets .

Jonathan Frech

@ JonathanFrech Ah, gentil!

gastropner

@ceilingcat Bonne prise!

gastropner

0

Python 2 , 244 128 120 octets

-8 octets grâce à @JonathanFrech

s='1'*78
print'7'*156+s+bin(int("8zlghh9gqo74zwzntkcjmoou35vvlbg1cmasrm6ny1iafcvw568sj",36))[2:].replace(*'08')+s+'3'*39

Essayez-le en ligne!

ovs
la source

120 octets .

Jonathan Frech

0

Befunge-93 , 500 octets

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"<

Essayez-le en ligne!

ItsJ0el
la source

Produire le PPCG Prime

C'est le PPCG Prime

Réponses:

Jelly , 55 54 52 47 46 octets

Comment ça fonctionne

Bubblegum , 51 octets

SOGL V0.12 , 52 51 octets

Mathematica, 107 octets

CJam, ASCII, 61

C, 519 427 414 396 377 octets

Java (OpenJDK 8) , 165 octets

Crédits

Retina , 129 octets

Lot, 364 335 333 octets

Javascript (ES6), 187 181 octets

C (gcc) , 269 267 octets

C (gcc) , 224 octets

Gelée , 86 octets

Python 2 , 309 158 155 136 135 octets

Python 2 , 137 octets

Gelée , 85 octets

PowerShell , 164 octets

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

Ruby, 109 octets

Python 2 , 112 octets

6502 code machine (C64), 142 122 octets

Explication

C (gcc) , 188 187 185 octets

Python 2 , 244 128 120 octets

Befunge-93 , 500 octets