Faites une quine mais avec une torsion.

Déclaration

La quine imprime son code mais met son premier caractère à la fin.
(Vous pouvez le faire à l'envers mais inclure cette note dans votre réponse)
La sortie doit alors être un programme qui est aussi une solution.

Exemple: Supposons que votre code était foobar, son exécution retournera oobarfce qui sera un autre programme valide.

foobar -> oobarf
oobarf -> obarfo
obarfo -> barfoo
barfoo -> arfoob
arfoob -> rfooba
rfooba -> foobar

Règles

• Votre code ne doit pas être une sortie d'une génération de code de quelqu'un d'autre qui est évidemment en train de voler
• Votre code doit comporter plus de 2 caractères (donc le code court n'est pas amusant)
• Votre code doit contenir au moins deux caractères différents (ex: +++n'est pas valide)

Notation

En tant que défi de golf par code, le code le plus court l'emporte.

Befunge-98 (PyFunge) , 2600 octets

ab*1'3:*2+*0pnd3*:::::::::::::::1'3:*3+*0p1'3:*5+*0p1'3:*d+*0p1'3:*f+*0p1'3:*fa++*0p1'3:*fd++*0p1'4'3*f-*0p1'4'3*7-*0p1'4'3*5-*0p6:*:*4-1p6:*:*4+1p6:*:*8+1p6:*:*a+1p6:*:*8+2p6:*:*f1++2p6:*:*f3++2pn75*1-:1'3:*4+*0p6:*:*f2++2pnaa*:::::::::::::::::1'3:*6+*0p1'3:*7+*0p1'3:*f1++*0p1'3:*f2++*0p1'3:*fe++*0p1'3:*ff++*0p1'4'3*e-*0p1'4'3*d-*0p1'4'3*4-*0p1'4'3*3-*0p6:*:*3-1p6:*:*2-1p6:*:*b+1p6:*:*c+1p6:*:*9+2p6:*:*a+2p6:*:*f4++2p6:*:*f5++2pn67*::::::::::1'3:*8+*0p1'3:*a+*0p1'3:*f4++*0p1'3:*f5++*0p1'4'3*f-5-*0p1'4'3*c-*0p1'4'3*2-*0p6:*:*1-1p6:*:*d+1p6:*:*b+2p6:*:*f6++2pna5*::1'3:*9+*0p1'3:*f3++*0p6:*:*1pn68*:::::1'3:*b+*0p1'3:*f8++*0p1'4'3*f-2-*0p1'4'3*9-*0p1'4'3*1+*0p6:*:*f7++2pne8*:::::::1'3:*c+*0p1'3:*f9++*0p1'4'3*f-1-*0p1'4'3*8-*0p1'4'3*2+*0p6:*:*f2++1p6:*:*f+2p6:*:*f8++2pnf4*:1'3:*e+*0p1'4'3*3+*2pn77*::::1'3:*f6++*0p1'4'3*f-4-*0p6:*:*f1++1p6:*:*c+2p6:*:*e+2pnb4*1-::1'3:*f7++*0p6:*:*f+1p6:*:*d+2pnf4*1-::1'3:*fb++*0p6:*:*7+2p1'3:*1+*2pnf4*2-1'3:*fc++*0pn95*:::1'4'3*f-3-*0p1'4'3*a-*0p1'4'3**0p6:*:*1+1pn87*1'4'3*b-*0pnac*2-:1'4'3*6-*0p1'4'3*3+*0pnf4*3-1'4'3*1-*0pn88*2-6:*:*5-1pnc9*1-6:*:*2+1pnb4*:6:*:*3+1p6:*:*6+1pn88*6:*:*9+1pnd4*1-6:*:*e+1pnc8*2-:1'3:**1p1'3:**2pnd7*2+6:*:*4+2pn75*6:*:*6+2pn>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>ab*1'3:*2+*0pnd3*:::::::::::::::1'3:*3+*0p1'3:*5+*0p1'3:*d+*0p1'3:*f+*0p1'3:*fa++*0p1'3:*fd++*0p1'4'3*f-*0p1'4'3*7-*0p1'4'3*5-*0p6:*:*4-1p6:*:*4+1p6:*:*8+1p6:*:*a+1p6:*:*8+2p6:*:*f1++2p6:*:*f3++2pn75*1-:1'3:*4+*0p6:*:*f2++2pnaa*:::::::::::::::::1'3:*6+*0p1'3:*7+*0p1'3:*f1++*0p1'3:*f2++*0p1'3:*fe++*0p1'3:*ff++*0p1'4'3*e-*0p1'4'3*d-*0p1'4'3*4-*0p1'4'3*3-*0p6:*:*3-1p6:*:*2-1p6:*:*b+1p6:*:*c+1p6:*:*9+2p6:*:*a+2p6:*:*f4++2p6:*:*f5++2pn67*::::::::::1'3:*8+*0p1'3:*a+*0p1'3:*f4++*0p1'3:*f5++*0p1'4'3*f-5-*0p1'4'3*c-*0p1'4'3*2-*0p6:*:*1-1p6:*:*d+1p6:*:*b+2p6:*:*f6++2pna5*::1'3:*9+*0p1'3:*f3++*0p6:*:*1pn68*:::::1'3:*b+*0p1'3:*f8++*0p1'4'3*f-2-*0p1'4'3*9-*0p1'4'3*1+*0p6:*:*f7++2pne8*:::::::1'3:*c+*0p1'3:*f9++*0p1'4'3*f-1-*0p1'4'3*8-*0p1'4'3*2+*0p6:*:*f2++1p6:*:*f+2p6:*:*f8++2pnf4*:1'3:*e+*0p1'4'3*3+*2pn77*::::1'3:*f6++*0p1'4'3*f-4-*0p6:*:*f1++1p6:*:*c+2p6:*:*e+2pnb4*1-::1'3:*f7++*0p6:*:*f+1p6:*:*d+2pnf4*1-::1'3:*fb++*0p6:*:*7+2p1'3:*1+*2pnf4*2-1'3:*fc++*0pn95*:::1'4'3*f-3-*0p1'4'3*a-*0p1'4'3**0p6:*:*1+1pn87*1'4'3*b-*0pnac*2-:1'4'3*6-*0p1'4'3*3+*0pnf4*3-1'4'3*1-*0pn88*2-6:*:*5-1pnc9*1-6:*:*2+1pnb4*:6:*:*3+1p6:*:*6+1pn88*6:*:*9+1pnd4*1-6:*:*e+1pnc8*2-:1'3:**1p1'3:**2pnd7*2+6:*:*4+2pn75*6:*:*6+2pn>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Essayez-le en ligne!

Cela a été un enfer.

Comment cela fonctionne:
Le programme est un tas d'instructions put qui assemble un programme B autour de lui qui imprime ensuite la moitié de l'octet source décalé deux fois.
Le programme est en fait 2 copies d'un programme de 1300 octets, c'est ainsi qu'il est garanti que le programme entier de 1300 octets est toujours exécuté dans son ensemble.

Meilleure explication:
chaque quine Befunge-98 doit contenir des symboles tels que @ou qet ,
Problème : Aucun de ces symboles n'est un bon point de départ, surtout depuis @et qarrête le programme instantanément.
Solution : se débarrasser de ces caractères dans le code source

Problème : comment?
Solution : utilisez les pcommandes (put) pour modifier le code source afin d'inclure les caractères requis qui imprimeront le contenu du code source décalé d'un octet et n'utilisez pas la gcommande qui triche.

Problème : (soupire quand cela prendra-t-il fin)
Une commande put affiche 3 valeurs n x yqui déterminent le caractère, coordonnée x, coordonnée y, mais lorsque l'initialisation de ces valeurs est divisée en deux, elle peut écrire de mauvais caractères dans le code source de début, ce qui la rend inutile pour quining.
Solution : (le dernier je le promets)
Utilisez 2 copies du code source, ce dernier étant le "bon" cela corrige accidentellement un autre problème qui est qu'une instruction put (commande p + les initialiseurs constants) qui est divisée en deux sera pas exécuté, ceci est corrigé en ayant 2 copies de chaque instruction. La dernière chose que cela doit fonctionner est de savoir comment fabriquer le code source entier à partir de la moitié?

Réponse :

C'est une preuve visuelle de la raison pour laquelle deux copies d'une chaîne décalée d'octets == Deux copies d'une chaîne décalée d'octets. Cela signifie que nous pouvons prendre la moitié du code, le déplacer en octets, puis l'imprimer deux fois (OU prendre la moitié du code, le déplacer en octets, imprimer, répéter [c'est ce qui se passe réellement])

Comment cela est mis en œuvre : Supposons que 0123456789abcdef est la source

Pseudocode Befunge:

0123456789abcv;;"123456789abcdef" < go this way <--
             >PS'0,   repeat 2x   ^

PS signifie Print Stack (pas une vraie instruction). Nous poussons la moitié du code source à l'envers sur la pile en utilisant ""ensuite nous imprimons la pile puis nous récupérons ( 'commande) le premier caractère 0que nous déplaçons devant le 'et l'imprimons en dernier ce qui provoque le décalage d'octets, puis nous répétons le cycle encore une fois pour imprimer la deuxième copie. Une technicité à traiter sont les symboles à l'intérieur de la source, cela peut causer des problèmes si nous l'écrivons lors de l'exécution du code source, j'ai contourné cela en ajoutant plus d'instructions put qui s'en occupent en externe.

Cela fait ressembler le code à ceci:

Explication : Surlignage
vert: Code qui prend en charge l'ajout de caractères dans les
lettres grises source (problème de mauvaise visibilité désolé): Code qui est ajouté par le code vert Surlignage
rouge: Code qui déplace le premier caractère de la seconde moitié du code source dans la zone bleue .
Surbrillance bleue: Voir Surbrillance rouge Surbrillance
orange: Code qui garantit que nous terminons après avoir écrit des copies décalées de 2 octets en plaçant une @commande (terminer) dans la zone jaune.

Nous espérons que les flèches permettront de mieux comprendre le déroulement du flux de code.

Voici la dernière partie difficile: d'
où vient le code source des bébés ?

Réponse courte: C # Magic
Réponse longue: 100+ extraits de code Befunge faits à la main compilés par du code C #. J'ai écrit manuellement environ 100 initialiseurs constants (un morceau de code befunge qui pousse un certain nombre à empiler) à la main, puis j'ai utilisé un programme C # personnalisé pour le compiler dans la sortie Befunge de 1300 octets, que j'ai ensuite copié collé deux fois et fait la finale programme.

Êtes-vous toujours là? Merci beaucoup d'avoir lu! (ou du moins faire défiler jusqu'à la fin)
J'espère que mes mauvaises blagues étaient amusantes et pas ennuyeuses.

Remarque: Aucune instruction put dans ce code ne crée une commande ag qui serait de la triche.

EDIT: J'ai vérifié le code en utilisant le code Javascript suivant dans TIO en utilisant des outils de développement

setInterval(()=>{document.getElementById("code").value = 
document.getElementById("output").value; 
document.getElementById("run").click();}, 2000);