Ecrire la quine d'itération de la période la plus longue limitée par 500 octets


16

Votre travail consiste à créer le quine d'itération de la période la plus longue , où la longueur de chaque programme de la séquence est limitée à 500 octets.

Autrement dit, si vous répétez les étapes suivantes:

  1. Commencez avec votre programme initial
  2. Exécuter le programme actuel
  3. Revenez à l'étape 2

Vous finirez par revenir à votre programme d'origine. Le nombre de programmes dans le cycle est votre score, que vous essayez de maximiser.

Aucun des programmes ne peut générer d'erreurs. Chaque programme doit également être exécuté de la même manière (par exemple, pas de versions, implémentations, options de compilateur, plates-formes, etc ...) différentes (EDIT: Oui, tout état externe tel que celui d'un générateur de nombres pseudo aléatoires a été inclus dans le dernier . L'état externe doit être "réinitialisé" après chaque exécution. Si vous utilisez de vrais nombres aléatoires, le pire des cas est supposé.)

Ce qui sépare ce défi de la période d'itération la plus longue (autre que 100 vs 500) est que chaque programme du cycle doit également être de 500 octets ou moins. Cela signifie que le cycle le plus long possible est (256 ^ 501 - 1) / 255 ou moins. C'est bien sûr un grand nombre, mais pas si grand en termes de quantité de code qu'il faut pour calculer. Le défi consiste donc à utiliser autant de possibilités (256 ^ 501 - 1) / 255 que possible, pas un défi de castor occupé.

Les programmes ne sont pas autorisés à accéder à son propre code source. Cependant, un programme vide est autorisé si vous le souhaitez (tant que vous suivez les autres règles).

Étant donné que la vérification manuelle des programmes serait difficile, vous pouvez déterminer le score à l'aide de méthodes théoriques. Vous devez inclure une explication du score et de l'exactitude avec votre programme. Si vous ne pouvez pas déterminer le score, vous pouvez utiliser à la place une limite inférieure du nombre de programmes dans le cycle comme score de facto. Vous êtes autorisé à le mettre à jour lorsque vous trouvez de meilleures limites inférieures ou si vous trouvez le score réel exact.

C'est un , donc le score le plus élevé gagne!

EDIT: Il est recommandé d'écrire votre score en notation scientifique, afin que les réponses soient plus facilement comparables. Il est tout à fait correct d'avoir également d'autres formes de partition, surtout si elles sont plus clairement liées à votre programme. De plus, les lecteurs sont encouragés à modifier les réponses précédentes pour s'y conformer.


2
"le cycle le plus long possible est (256 ^ 501 - 1) / 255 ou moins" --- ce n'est pas nécessairement vrai, le programme peut passer plusieurs fois par le même état avant de revenir à l'original s'il manipule un objet externe ( comme l'état RNG ou la graine)
JDL

2
@JDL qui devrait être contraire aux règles, à mon humble avis - s'il stocke un état ailleurs que dans le code source, ce n'est pas un quine d'itération approprié.
Nathaniel

1
@Nathaniel Je ne le catégoriserais pas comme stockant un état ailleurs, il utilise simplement des points d'entrée qui sont une partie valide du langage de programmation dans lequel il est implémenté. son propre code source.
JDL

1
@JDL non, ce sont des choses différentes. Tout programme dans n'importe quel langage doit évidemment s'appuyer sur des choses qui sont implémentées en dehors du code source, mais le stockage de l' état en dehors du code source est différent. Cela signifierait que la sortie du programme n'est pas une fonction déterministe de son code source, mais dépend plutôt d'un autre contexte externe qui a été modifié par les exécutions précédentes. Cela ne devrait pas être autorisé dans un défi quine, à mon humble avis, et la déclaration du PO sur la durée maximale du cycle indique qu'il était destiné à être interdit ici.
Nathaniel

3
@JDL comme je suis certain que vous le savez, dans un langage déterministe, le pointeur d'instruction stocke uniquement l'état pendant l'exécution d'un programme, et non entre les invocations de celui-ci. Votre exemple à 5 états n'est pas possible si la sortie du programme est une fonction déterministe de sa source.
Nathaniel

Réponses:


12

Perl 6 , 1263988,86×dix835 itérations

$!=Q~~;<say "\$!=Q~{chrs(my@a=[R,] polymod :126[$!.ords]+1: 126 xx*)x?(@a-399)}~;<$_>~~.EVAL">~~.EVAL

Essayez-le en ligne!

Cela parcourt toutes les combinaisons possibles des 126 premiers octets de longueur 398 et moins (à l'exclusion des chaînes avec des octets NUL de tête). Si vous voulez voir qu'il retourne réellement à la première itération, vous pouvez réduire la longueur à 1 en modifiant la limite comme ceci .

Explication:

Chaque itération incrémente la chaîne, stockée sous forme de base 126, puis la reconvertit en base 126. Elle le fait jusqu'à ce qu'elle atteigne une chaîne de longueur 399, puis réinitialise la chaîne pour la vider à nouveau. Si vous avez du mal à conceptualiser le nombre, imaginez-le à la place avec dix octets. À partir de 0, incrémentez jusqu'à 4 chiffres 1000et réinitialisez. Il s'agit de dix4-1 itérations ( 0chaîne incluse ou vide dans le cas de mon programme).

$!=Q~~;         # Start with an empty string
< ... >~~.EVAL  # Set a string to $_ and EVAL it
  say "\$!=Q~{...}~;<$_>~~.EVAL"   # Print the program with the string replaced by
                       :126[$!.ords]   # The string converted from base 126
                                    +1 # Incremented
          [R,] polymod                : 126 xx*  # Back to base 126
chrs(                                )  # Back to a string
     my@a=                            x?(@a-399)  # Only if it isn't 399 characters

1
Wow, vous avez fait ça très vite, j'ai presque fini avec le mien, mais je vais probablement le terminer demain (le mien sera à Gol> <>)
KrystosTheOverlord

Ce calcul suggère que vous avez largement surestimé votre score. Le numérateur est le nombre de chaînes de longueur 397 qui utilisent 126 symboles. (J'ai dû distribuer la fraction dans la somme car le wolfram alpha agissait bizarrement.)
PyRulez

@PyRulez Je pense que mon numéro est correct, car il s'agit essentiellement d'itérer un nombre de base 126 jusqu'à 399 chiffres ... Je pense que mon explication était éteinte
Jo King

@JoKing ah oui, je pense que l'explication était le problème. Vous avez changé 397 en 398, ce qui fait que votre score n'est plus une surestimation. Vous le sous-estimez peut-être (puisque vous n'avez inclus que des cordes de longueur exactement 398 dans la partition), mais ça va.
PyRulez

2

Enchantements runiques , 64654 106 ; 122 387 -1 ≈ 2.638 × 10 807 itérations

"3X4+kSq'ƃZ,r{1?{1[:1Z%1+:a=+:d=+:3X4+=+:6X2+=+:'€(c*?~1-1kq}͍f1+0Bl1=6*?S1-Skql͗2=4*?{͍]}B͍l1=6*?kS1-Sq]}@

Essayez-le en ligne!

Alerte: le n'est pas affiché correctement, il devrait être `` (0x80).

Plutôt que la pile, utilisez une chaîne et les opérateurs de pile modifiés avec ͍ pour modifier une chaîne plutôt que la pile (voir la révision précédente). En tant que tel, chaque caractère est limité à 1 octet (plage de 0 à 127, moins les caractères problématiques), mais avec plus de 3 fois plus (car il y a moins de passe-partout de traitement en raison de ne pas avoir à ignorer les caractères de combinaison Unicode, comme ainsi que certaines autres économies d'octets), il atteint un plus grand nombre d'itérations.

Si le codage en tant que vrai gros endian est autorisé (c'est-à-dire, ayant des valeurs d'octets supérieures à 127 sans 0x00octets d' interjection ), cela peut atteindre 251 387 -1 ≈ 4,717 × 10 928 itérations. Cependant, l'encodage latin de TIO empêche cela, comme l'a noté Erik l'Outgolfer dans sa réponse Python 2. Je devrais vérifier si cela fonctionne localement avant de réclamer ce score.

Devrait être en mesure de remplacer f1+0Bpar '0B(il y a une non-impression0x16 là-bas), mais il me combattait (les choses ne voulaient pas se / sauter / retourner correctement), alors je l'ai laissé seul. Cela ferait passer la structure big-endian de 387 à 388.


1

DOS COM, 49 octets, période 2 ^ 3608

00000000  be 31 01 89 f7 b9 f4 02  f9 ac 14 00 aa 39 ce 72  |.1...........9.r|
00000010  f8 31 c9 b4 3c ba 2b 01  cd 21 89 c3 b4 40 b9 f4  |.1..<.+..!...@..|
00000020  01 ba 00 01 cd 21 b4 3e  cd 21 c3 71 2e 63 6f 6d  |.....!.>.!.q.com|
00000030  00                                                |.|

Assemblage d'origine pour créer:

 BITS 16
 ORG 0100h
   mov si, l
   mov di, si
   mov cx, 500 + 0100h
   stc
n: lodsb
   adc al, 0
   stosb
   cmp si, cx
   jb n
   xor cx, cx
   mov ah, 3ch
   mov dx, f
   int 21h
   mov bx, ax
   mov ah, 40h
   mov cx, 500
   mov dx, 0100h
   int 21h
   mov ah, 3eh
   int 21h
   ret
f: db "q.com", 0
l: db 0

Ce petit bijou écrit la prochaine phase sur q.com plutôt que la sortie standard à cause des valeurs nulles et autres choses que le terminal ne peut pas gérer. La technique de racine quine est équivalente à la stringification et la salle de charge utile est utilisée comme compteur 3608 bits. En raison du fonctionnement de DOS, l'état initial du compteur contient des débris de tout ce qui était en mémoire avant sa première exécution.

L'entrée originale de 49 octets est inaccessible, donc si vous voulez marquer cela comme 500 octets, allez-y.


1

C # (compilateur interactif Visual C #) , indicateurs: /u:System.Numerics.BigIntegeret/r:System.Numerics

Résultat: 10 10332

Merci à JoKing qui a augmenté mon score de 10 255 * 2 - 1 à maintenant!

var i=Parse("0");var s="var i=Parse({0}{2}{0});var s={0}{1}{0};Write(s,(char)34,s,(++i).ToString().Length<333?i:0);";Write(s,(char)34,s,(++i).ToString().Length<333?i:0);

Essayez-le en ligne!

Explication

Incrémente un BigInteger à chaque itération, jusqu'à ce que sa longueur devienne trop grande, ce qui dans ce cas nous ramène instantanément au quine d'origine.

//The BigInteger that will be incremented
var i=Parse("0");
//The string that encodes the quine
var s="var i=Parse({0}{2}{0});var s={0}{1}{0};Write(s,(char)34,s,(++i).ToString().Length<333?i:0);";
//Print out the string, with every {0} replaced with quotes and the {1} replaced with the original string
Write(s,(char)34,s,
//And the {2} is replaced to the BigInteger+1 if the BigInteger wouldn't be too long, else 0
(++i).ToString().Length<333?i:0);

1

Python 2 , 500 octets,252219

#coding=L1
s=""""""
for i in range(220-len(s.lstrip("ÿ")))[:219]:s=s[:i]+chr(ord(s[i])%255-~(s[i]in"!$&"))+s[i+1:]
S='#coding=L1\ns="""%s"""\nfor i in range(220-len(s.lstrip("\xff")))[:219]:s=s[:i]+chr(ord(s[i])%%%%255-~(s[i]in"!$&"))+s[i+1:]\nS=%%r;print S%%%%s%%%%S';print S%s%S

Notez qu'il existe une nouvelle ligne de fin. Il pourrait être supprimé ci-dessus si le surligneur de syntaxe s'impose.

Malheureusement, vous ne pouvez pas exécuter ce programme dans TIO, car il est codé en latin-1.

Ci-dessus, scontient 219 0x01 octets. Après l'exécution du programme, sa source est imprimée, à l'exception d'une différence: sa été incrémenté comme un nombre big-endian base-252, donc son caractère le plus à gauche a été "incrémenté" à 0x02. Les octets 0x00, 0x22, 0x25 et 0x5C sont évités, donc, si un caractère de la chaîne devient l'un de ceux après l'incrémentation, le caractère lui-même est incrémenté à nouveau.

  • 0x00 (null): un fichier source Python ne peut pas contenir de caractères nuls.
  • 0x22 ( "): il y a un danger de formation de trois octets 0x22 d'affilée, c'est-à-dire """, ou le dernier caractère de la chaîne devenant" , donc la chaîne serait fermée prématurément.
  • 0x25 ( %): le formatage de chaîne de type printf est utilisé avant l'achèvement du squelette de quine, donc un %non adjacent à un autre %danss va causer des problèmes. Malheureusement, il n'est pas possible de réorganiser le formatage pour éviter cette mise en garde.
  • 0x5C ( \): Il est possible que le \soit utilisé comme marque d'échappement dans la chaîne, au lieu de mot pour mot, donc il est évité.

Par conséquent, 252 octets sur 256 sont utilisables. Si scontient 219 0xFF (ÿ ) octets, il est simplement revenu à 219 0x01 octets, terminant ainsi le cycle.

Compte tenu de ce qui précède, nous avons 252219 chaînes possibles, donc autant de programmes dans l'ensemble.

252219=8067118401622543607173815381864126969021321378412714150085501148172081568355283332551767558738710128769977220628694979838777041634307806013053042518663967641130129748108465109552157004184441957823830340121790768004370530578658229253323149648902557120331892465175873053680188287802536817909195292338112618632542000472094347226540339409672851252596442228662174845397731175044304251123874046626291460659909127172435776359148724655575878680270692451120531744950544969860952702932354413767504109600742385916705785109741289800204288


1

Clean ,2512262.1×dix542

  • 251 39 dépendance suppriméeText
  • 251 122 fonction d'incrémentation golfée
  • 251 128 chaînes sources combinées de préfixe et de suffixe
  • 251 188 dépendance éliminée surGast.GenLibTest

Présenté au format xxd en raison de UTF-8 non imprimables / non valides:

00000000: 6d6f 6475 6c65 2071 3b69 6d70 6f72 7420  module q;import 
00000010: 5374 6445 6e76 3b53 7461 7274 3d28 7325  StdEnv;Start=(s%
00000020: 2830 2c34 3129 2c3f 5b27 0101 0101 0101  (0,41),?['......
00000030: 0101 0101 0101 0101 0101 0101 0101 0101  ................
00000040: 0101 0101 0101 0101 0101 0101 0101 0101  ................
00000050: 0101 0101 0101 0101 0101 0101 0101 0101  ................
00000060: 0101 0101 0101 0101 0101 0101 0101 0101  ................
00000070: 0101 0101 0101 0101 0101 0101 0101 0101  ................
00000080: 0101 0101 0101 0101 0101 0101 0101 0101  ................
00000090: 0101 0101 0101 0101 0101 0101 0101 0101  ................
000000a0: 0101 0101 0101 0101 0101 0101 0101 0101  ................
000000b0: 0101 0101 0101 0101 0101 0101 0101 0101  ................
000000c0: 0101 0101 0101 0101 0101 0101 0101 0101  ................
000000d0: 0101 0101 0101 0101 0101 0101 0101 0101  ................
000000e0: 0101 0101 0101 0101 0101 0101 0101 0101  ................
000000f0: 0101 0101 0101 0101 0101 0101 0101 0101  ................
00000100: 0101 0101 0101 0101 0101 0101 275d 2c73  ............'],s
00000110: 2528 3432 2c39 3939 292c 712c 732c 7129  %(42,999),q,s,q)
00000120: 3b71 3d69 6e63 2721 273b 3f5b 683a 745d  ;q=inc'!';?[h:t]
00000130: 2363 3d68 2b69 6628 616e 7928 283d 3d29  #c=h+if(any((==)
00000140: 6829 5b27 ff09 0c26 5b27 5d29 2702 2727  h)['...&['])'.''
00000150: 0127 3d5b 633a 6966 2863 3e68 2969 643f  .'=[c:if(c>h)id?
00000160: 745d 3b3f 653d 653b 733d 226d 6f64 756c  t];?e=e;s="modul
00000170: 6520 713b 696d 706f 7274 2053 7464 456e  e q;import StdEn
00000180: 763b 5374 6172 743d 2873 2528 302c 3431  v;Start=(s%(0,41
00000190: 292c 3f5b 2727 5d2c 7325 2834 322c 3939  ),?[''],s%(42,99
000001a0: 3929 2c71 2c73 2c71 293b 713d 696e 6327  9),q,s,q);q=inc'
000001b0: 2127 3b3f 5b68 3a74 5d23 633d 682b 6966  !';?[h:t]#c=h+if
000001c0: 2861 6e79 2828 3d3d 2968 295b 27ff 090c  (any((==)h)['...
000001d0: 265b 275d 2927 0227 2701 273d 5b63 3a69  &['])'.''.'=[c:i
000001e0: 6628 633e 6829 6964 3f74 5d3b 3f65 3d65  f(c>h)id?t];?e=e
000001f0: 3b73 3d22                                ;s="

Essayez-le en ligne!

Incrémente une chaîne 226 octets par toutes les valeurs d'octets hors \0, \n, \r, 'et \.

La raison pour laquelle nous évitons ces caractères est:

  • \0 met le compilateur en colère
  • \net \rne peut pas apparaître dans les listes de caractères
  • ' mettrait fin à la liste des caractères
  • \ pourrait causer des problèmes s'il précède un caractère échappable

Une fois la chaîne \377terminée, elle s'enroule sur tous les \001s, donnant le programme d'origine.


La sortie (au moins sur TIO) est le caractère de valeur ordinale 128, mais composé des deux octets C2 80. Est-ce le même que le comportement sur votre machine locale?
Jo King

1
@JoKing Oh, non, je reçois un seul octet sur ma machine. TIO modifie la sortie lorsqu'elle n'est pas UTF-8 valide (et les fichiers d'entrée aussi).
Οurous

1
@JoKing J'ai changé la réponse à un nouveau format qui permet de voir le bon comportement sur TIO.
Feburous

0

Gol> <> , 70 octets, 39039000 itérations

":1=l8:*6+=S&Q~:'~'=Q~~'H#'||lPaa*5*=?1:1=Q$~$~|:1)lPaa*5*(Q?:|r2ssH##

Wow, c'est beaucoup plus bas que je ne le pensais ... Prochaine étape! Faire plus d'itérations !!!

Essayez-le en ligne!


il ne semble rien supprimer une fois qu'il atteint 500, ajoute
Jo King

Est-ce que cela fonctionne même du tout? Je ne parviens pas à faire "incrémenter le dernier caractère"
ASCII uniquement le

@ ASCII-only Maintenant, cela fonctionne, désolé avant, j'avais foiré une section tout en travaillant à réparer le tout. Cela fonctionne maintenant, désolé pour le dérangement !!!
KrystosTheOverlord

@JoKing L'octet NUL est le processus de suppression, maintenant le programme devrait supprimer jusqu'à ce qu'il soit presque parti, puis supprimer le NUL et incrémenter le dernier caractère, s'il s'agit d'un ~, il sera converti en un '#', revenant en arrière À la normale!!!
KrystosTheOverlord
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.