Sortie du Trinity Hall Prime

38

Basé sur cette question Math.SE ; numéro copié de cette réponse . Nombre à l’origine d’ une vidéo Numberphile , bien sûr.

Votre tâche consiste à générer le nombre premier à 1350 chiffres suivant:

888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888111111111111111111111111888888111111111111111111111111888888111111811111111118111111888888111118811111111118811111888888111188811111111118881111888888111188811111111118881111888888111888811111111118888111888888111888881111111188888111888888111888888111111888888111888888111888888888888888888111888888111888888888888888888111888888111888888888888888888111888888811188888888888888881118888188811188888888888888881118881188881118888888888888811188881118888111888888888888111888811111888811118888888811118888111111188881111111111111188881111111118888111111111111888811111111111888811111111118888111111111111188881111111188881111111111111118888811118888811111111111111111888881188888111111111111111111118888888811111111111111111111111888888111111111111111111111111118811111111111111111111111111111111111111111111062100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001

Vous pouvez éventuellement inclure des nouvelles lignes dans la sortie.

Règles

  • Ceci est , donc pas d'entrée.
  • Votre programme doit être terminé en une heure sur un ordinateur standard. S'il est proche, j'utiliserai le mien à des fins de test. Si votre programme dure plus d'une minute ou ne se termine pas sur TIO, veuillez indiquer l'heure sur votre ordinateur.
  • C'est du , donc le code le plus court, en octets, gagne.
Stephen
la source
3
"nombre à l'origine d'une vidéo numberphile" Je pense que cela provient du professeur mckee: P
undergroundmonorail
Qu'en est-il de ce premier ?
sergiol

Réponses:

31

Gelée , 74 71 69 68 66 octets

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

Essayez-le en ligne!

Comment ça marche

Le littéral “©ạ-3ṗÇñ"ỤḍV8żṢ?ḤsMVE[,Ṃƭ"ḞÇsẇʂ(ụFsẠʂẆŀṣ’remplace tous les caractères par leurs points de code dans la page de code de Jelly et interprète le résultat comme un nombre (bijectif) base-250, donnant le nombre entier suivant.

103877200905186099028820568168804302565394743652609510039112658230540917082292838565138059974

Ensuite, ḃ19convertit ce nombre en base bijective 19, donnant le tableau de chiffres suivant.

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

Maintenant, ĖŒṙénumère les chiffres et effectue le décodage de longueur d’exécution, produisant le tableau suivant.

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

Ensuite, ị⁾81indexe dans la chaîne 81 , en remplaçant les nombres impairs par le caractère 8 , le nombre pair par le caractère 1 . Ensuite, s30divise le résultat en morceaux de longueur 30. En affichant un morceau par ligne, le résultat se présente comme suit.

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

Maintenant, m0concatène le tableau de morceaux avec une copie inversée de lui-même. Ensuite, Zcompresse le résultat, en transposant des lignes et des colonnes.

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

0est un nilad imparable. Le résultat précédent est donc imprimé (sans sauts de ligne) et la valeur de retour est définie sur 0 .

62est un autre nilad imparable, le résultat d'avant ( 0 ) est imprimé et la valeur de retour est définie sur 62 .

ȷ446est encore un autre nilad imparable. 62 est imprimé et la valeur de retour est fixée à 10 446 .

Enfin, incrémente le résultat. Le résultat final ( 10 446 + 1 ) est imprimé à la fin du programme.

Dennis
la source
ooo cool s'il vous plaît ajouter une explication: D
HyperNeutrino
@HyperNeutrino basé sur la sortie (mais avec mon manque total de connaissances sur Jelly), il y a un peu de réflexion qui se passe ou quelque chose dans ce genre
Stephen le
1
@Stephen Eh bien, je veux dire en premier lieu, il s'agit d'un nombre sophistiqué, puis d'une conversion en "base bijective" (quoi que cela signifie, je vais essayer de le comprendre), puis d'une énumération, puis d'une longueur, puis d'un index dans [8, 1]... Oh, c'est intelligent! Je vole ce truc j'espère que ça ne vous dérange pas :))) et puis oui ajoutez tout ça bizarre 06210..01. nice :)
HyperNeutrino
2
@HyperNeutrino Ajout d'une explication.
Dennis
Up a voté pour le "graphisme" seul. C'est assez gentil, j'aimerais avoir compris Jelly :)
pinkfloydx33
7

SOGL V0.12 , 81 78 75 73 octets

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

Essayez-le ici!

Explication:

...“                 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
dzaima
la source
6

Gelée , 136 octets

“ßṪṭ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Ḍ

Essayez-le en ligne!

Explication (numéros abrégés)

“ßṪṭ...*Ḣɲ’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 octets grâce à Dennis utilisant des “...’littéraux au lieu de nombres normaux

HyperNeutrino
la source
“...’les littéraux économisent beaucoup d'octets. tio.run/…
Dennis
@ Dennis Oh, bon sang, c'est encore plus illisible. Beau! Merci! : D
HyperNeutrino
0;6;2;1;semble terriblement verbeux.
Magic Octopus Urn
@MagicOctopusUrn Oui, je pourrais probablement le raccourcir un peu;
J'examinerai
6

Gelée ,  133 84  73 octets

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

Essayez-le en ligne! (footer formate le nombre décimal avec les dimensions qui donnent le blason).

Comment?

Une forme codée de longueur binaire d'un format binaire du côté gauche du blason 8et 1jusqu'à la ligne avant celle commençant 0621par celle 0621indiquée, puis multipliée par 10 446 et incrémentée.

“...’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
Jonathan Allan
la source
5

Charbon de bois , 107 104 98 96 87 79 octets

E³⁰✂”}∧Pt→8⌕LJε`‽∨↑¬KαfGⅉKMκ⎆wp◧⪫⊘^≦#⁸¹"π✂×OγX‹nI”×ι¹⁵×⊕ι¹⁵‖CM²⁸←621M²⁵¦¹⁴1UB0

Essayez-le en ligne! Lien vers le code détaillé pour une explication

ASCII seulement
la source
4

Proton , 368 octets

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')

Essayez-le en ligne!

HyperNeutrino
la source
4

Ruby , 180 octets

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

Essayez-le en ligne!

178 octets + 2 octets pour -Kn(force le codage ASCII.)

43 caractères généralement non imprimables entre les premières citations. 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

Comment?

Tout le monde était en train de coder la durée, donc je voulais essayer quelque chose de différent.

La version "image" formatée du nombre premier peut être séparée en deux parties: une grille de 8 et 1 de 30x30, et une deuxième section composée principalement de zéros pouvant être codés en dur. En se concentrant sur la première partie, nous observons que cette position est symétrique au centre. Si nous pouvons produire la moitié gauche, nous ne pouvons imprimer que la moitié de chaque ligne avec son envers.

La moitié d'une ligne est composée de 15 caractères. Si nous remplaçons les 8 par des zéros, chaque ligne peut être interprétée comme un nombre binaire de 15 bits. De manière pratique, la distance d'édition entre chaque ligne consécutive est généralement faible. J'ai donc décidé d'implémenter ma solution en stockant la première ligne s( 888888888888888qui devient juste 0) et en appliquant une série d'opérations de retournement de bits s, en imprimant le résultat à chaque fois. .

Comme chaque ligne a une longueur de 15 bits, j'ai codé ces opérations sous forme de chiffres hexadécimaux - par exemple, si l'opération est b(ou 11), nous retournons le bit 11. Certaines lignes diffèrent de plus d'un bit, elles nécessitent donc une chaîne hexadécimale. chiffres. Il nous reste un peu ( f) afin que nous puissions l’utiliser comme délimiteur entre ces chaînes et comme valeur "ne rien faire". Exemple ci-dessous (vous pouvez voir ces lignes dans le post référencé dans la question):

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

Pour mettre tout cela ensemble, nous encoderions 0123456789ab, puis nous séparerions avec f, ne ferions rien avec f, alors 5. Cela fonctionne parce que nous allons faire .split(?f)plus tard pour obtenir chaque ensemble d'opérations par ligne, ce qui donnera ["0123456789ab", "", "5"], et ""sera un no-op.

La différence entre les lignes 3 et 4 ci-dessus est de loin le plus long ensemble de modifications, et la distance de modification entre deux lignes consécutives est généralement de 0 à 2; je dirais donc que cet encodage est relativement peu coûteux, même si je suis sûr qu'il peut Soyez améliorés.

La totalité de la chaîne encodée finit par être fff0123456789abff5f6f7ff8f4f3f012fff8bfef7af69df458cf01237bf6af59f48f237f16f045f3f12f0(86 octets), ce qui donnera la grille 30x30 entière. Mais nous n'avons pas encore fini ...

Les chiffres hexadécimaux peuvent être représentés par 4 bits ( b-> 1100, etc.). Cela signifie que si nous voulons coder notre chaîne 4 bits à la fois plutôt que d'utiliser des octets, nous pouvons couper la longueur de la chaîne de moitié. C'est donc ce que j'ai fait - l'hexdump montre la chaîne représentée dans 43 octets. Après cela, il ne reste plus qu'à utiliser la nifty String # unpack de Ruby avec H*(interpréter comme chaîne hexadécimale, le gros doigt en premier) pour développer la chaîne de 43 octets dans la version à 86 octets que nous connaissons et adorons, et effectuer une boucle sur chaque ensemble d'opérations renverser des bits - pour notre chaîne stockée set une opération que cnous effectuons s ^ 2**c.to_i(16)pour renverser le bit correspondant.

Une fois que chaque série de modifications est terminée, nous complétons le fichier binaire résultant à 15 bits, commutons tous les 0 à 8, puis imprimons le résultat et l'inverse. Comme indiqué précédemment, la partie du numéro située après la grille 30x30 peut être codée en dur, nous le faisons doncputs'0621'+?0*445+?1 .

La chaîne encodée finale n'a aucune possibilité de travailler sur TIO, la version de TIO utilise donc des échappements, qui fonctionnent toujours mais sont plus longs.

Goûter
la source
3

Python 2 , 760 523 329 205 196 octets

-237 octets grâce à Stephen. -124 octets grâce à 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'

Essayez-le en ligne!

totalement humain
la source
526 octets en déclarant des variables pour 8et 1et en combinant621
Stephen
Oh. XD Je viens de l’automatiser, donc je n’ai pas vu le fichier 621. Merci!
totalement humain
2
205 octets en compressant la liste. Un peu plus si vous voulez seulement utiliser des octets imprimables.
Jonathan Frech
2

CJam, 532 412 340 231 210 209 octets

". $ MBZp & 8OIoLs7Rv / BEqN # 1r ~ E $ O% 6 ^ UO = \ z: (Iw] l \ LQ.g.aWf + {2; sur | 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

Essayez-le en ligne

L'encodage de longueur de plage a été étendu à partir de la base 92 (la base 250 a conduit à des caractères multi-octets, donc elle a dû être ajustée). En outre, 4341089843357287864910309744850519376est étendu à partir de la base 92 et converti en binaire. Un 1 signifie que la longueur de la plage est deux chiffres, 0 signifie qu'il s'agit d'un chiffre. Par exemple, les 4 premiers chiffres de la représentation binaire sont 1101 car les quatre premières exécutions sont [93,8],[24,1],[6,8],[24,1](93 8, 24 1, etc.).

geokavel
la source
2

JavaScript, 454 450 332 207 204 octets

-4 octets grâce à Stephen. -125 octets grâce à Shaggy et Dom Hastings.

_=>[...`]






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

Il y a un bateau de non-imprimables dans cette réponse, alors voici un 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())

totalement humain
la source
Je crois que renvoyer la valeur d'une fonction serait valide.
Stephen
Oh, d'accord, merci. Pourriez-vous s'il vous plaît aussi faire la partie HTML? : PI sérieusement ne sais pas beaucoup de cela, je viens de choisir JS en raison de la remplacer regex soignée. EDIT : Merci. : D
totalement humain
Vous pouvez inverser les guillemets autour du dernier +'1'comme c'est déjà Stringet +'0621'peut être +0+621!
Dom Hastings
1
222 octets - Dernier, c'est promis!
Shaggy
3
[...`]me rend tellement fou
ETHproductions
2

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

Je suis venu avec cela pendant que je travaillais sur la solution de i cri everytim dit que c’était suffisamment différent pour justifier une publication autonome.

Ceci inclut une charge de fichiers non imprimables entre le ]et le ,. Suivez donc le lien TIO ci-dessous pour le visualiser avec des échappements Unicode (chaque séquence de \u4 chiffres compte pour 1 octet).

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

Essayez-le en ligne

Hirsute
la source
2

MATLAB / Octave , 319 318 octets

Ceci est ma première tentative à ce défi. Encore un peu volumineux et il existe probablement des moyens plus efficaces de le faire, mais je pensais le publier de toute façon, car la méthode était plus intéressante que la simple compression.

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

Essayez-le en ligne!

La méthode utilisée ici consiste à utiliser un schéma de tri Run-Length-Encoding.

Nous commençons avec le numéro d'origine et comptons le nombre de chiffres consécutifs. Celles-ci sont écrites dans le résultat ci-dessous sous la forme du compte suivi directement du chiffre (espace séparé pour plus de clarté).

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

Si l'une des valeurs est supérieure à 95, nous la scindons en plusieurs morceaux de 95 ou moins - cela ne se produit que pour les 445 0 qui deviennent quatre ensembles de 95 0 et un ensemble de 65 0. Nous complétons également les nombres inférieurs à 10 avec un 0 pour que tous les éléments aient trois caractères. Cela donne avec les espaces supprimés:

938241068241068061018101018061068051028101028051068041038101038041068041038101038041068031048101048031068031058081058031068031068061068031068031188031068031188031068031188031078031168031048011038031168031038021048031148031048031048031128031048051048041088041048071048141048091048121048111048101048131048081048151058041058171058021058201088231068261028441010016012011950950950950650011

Avec le recul, à ce stade, j’aurais pu franchir cette étape avant de fusionner le tout, mais c’est que vous vivez et apprenez. Nous faisons quelque chose d'intelligent qui consiste à prendre le nombre pour chaque groupe (2 chiffres) et nous en ajoutons 31. Comme ils sont tous <96, le nombre obtenu est la valeur ASCII d'un caractère imprimable (32 à 126). Nous donnant des comptes de:

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

Après un peu de remodelage dans MATLAB pour le rendre plus favorable au décodage, puis des 'caractères d' échappement avec ''(sinon, MATLAB divise les littéraux de chaîne), nous nous retrouvons avec la chaîne intelligente:

|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

C'est la racine du code. Dans le code, tout ce que je fais alors est de remodeler le tableau en une chaîne 2D avec 128 paires de caractères. Pour chaque paire, le premier caractère est soustrait de 31, puis le deuxième caractère est affiché autant de fois.

Le résultat est le nombre premier d'origine:

888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888111111111111111111111111888888111111111111111111111111888888111111811111111118111111888888111118811111111118811111888888111188811111111118881111888888111188811111111118881111888888111888811111111118888111888888111888881111111188888111888888111888888111111888888111888888111888888888888888888111888888111888888888888888888111888888111888888888888888888111888888811188888888888888881118888188811188888888888888881118881188881118888888888888811188881118888111888888888888111888811111888811118888888811118888111111188881111111111111188881111111118888111111111111888811111111111888811111111118888111111111111188881111111188881111111111111118888811118888811111111111111111888881188888111111111111111111118888888811111111111111111111111888888111111111111111111111111118811111111111111111111111111111111111111111111062100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001

Modifications:

  • réarrangé la chaîne magique afin que je puisse me débarrasser d'une transposition après la refonte. Enregistre un octet.
Tom Carpenter
la source
2

05AB1E , 76 octets

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

Essayez-le en ligne!


J'ai volé ça à Dennis:

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

A noté qu'il alterne toujours entre 8 et 1, j'ai donc compté les longueurs de chaque manche (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']

Tout réuni et converti en un entier de base 10:

3954184379309026812828704944878416720438306456270310298603957651230861078960874182787979106461

Le comprime plus loin en base 255:

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

Ensuite, après avoir créé le bit compressé ... Il ne reste plus qu’à le manipuler.

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.

Sortie finale:

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
Urne Magique De Pieuvre
la source
2

C (gcc) , 277 octets

J'ai l'impression que cette ficelle pourrait être raccourcie d'une manière ou d'une autre.

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

Essayez-le en ligne!

gastropner
la source
1

Perl 5 , 307 octets

$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)

Essayez-le en ligne!

Xcali
la source
1

Bubblegum , 88 octets

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

Essayez-le en ligne!

Dom Hastings
la source
1

Ruby , 194 octets

$><<?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

La partie supérieure est codée RLE, le reste est simplement codé en dur.

Essayez-le en ligne!

GB
la source
1

Kotlin , 339 octets

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

Essayez-le en ligne!

jrtapsell
la source
1

CJam ( 108 81 octets)

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

Démo en ligne

Dans le cas où l'encodage de caractères obéit à ce qui précède, ici, il est encodé en 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

La séquence initiale de 8 et de 1 est divisée en une moitié gauche et une longueur codée sous la forme de longueurs de séquences alternées. Les séries de plus de 24 sont divisées en séries de 24 au maximum, séparées par des séries de 0, afin que les longueurs puissent être codées en base 25 puis en base 256 pour les compresser.

Peter Taylor
la source
1

JavaScript (ES2017), 287 octets

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

Utilise une approche légèrement différente de la réponse de @icrieverytim . -10 octets grâce à la suggestion de @Shaggy d'utiliser à la replaceplace 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>

Dom Hastings
la source
1
287 octets .
Shaggy
1

/// , 260 octets

/;/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

Essayez-le en ligne!

Rien de très intéressant, juste un peu de compression.

Conor O'Brien
la source
1

Mathematica, 192 octets

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

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

Eric Towers
la source
1

Python 2 , 191 190 188 octets

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

Essayez-le en ligne!

Même principe que ma réponse ici

TFeld
la source