Connexes: Interquine

Le programme A génère le code du programme B lorsqu'il est exécuté, et B génère la source de C et C génère la source de A.

Cette fois, vous ne pouvez pas échanger deux personnages et échanger à nouveau :)

Exigences:

• Une seule langue dans tous les programmes
• Des restrictions standard contre les échappatoires s'appliquent
• Tous les programmes sont différents. Un programme qui sort lui-même n'est pas admissible. Deux qui sortent l'un de l'autre ne sont pas non plus admissibles.
• Tous les programmes sont non vides ou d'une longueur d'au moins 1 octet.
• Il n'y a rien à lire car stdin est connecté à /dev/null(vous pouvez abuser de cette règle si vous le pouvez ). La sortie passe à stdout.
• N'utilisez pas de fonctions qui génèrent des résultats aléatoires.

Additionnel:

• Donner des explications si possible

Le score est la longueur du plus court (pouvez-vous générer un programme long à partir d'un court?). Veuillez écrire la durée de tous les programmes et mettre en surbrillance le plus petit nombre. Le retour à la ligne ne compte pas. Le score le plus bas l'emporte .

Python 3 , 50 octets

s='s=%r;print(s%%(s,%i*2%%7))';print(s%(s,1*2%7))

Essayez-le en ligne!

La dernière expression passe de 1*2%7à 2*2%7à 4*2%7ensuite revenir à 1*2%7.

RProgN 2 , 12 8 octets

1
«\2*7%

Expliqué

1   # Push the digit to the stack.

«\2*7%
«       # Define a function from here to the matching ». As there is no matching », define it from here to the end of the program, and continue running.
 \      # Flip the function under the constant number.
  2*    # Multiply by 2.
    7%  # Modulo 7.

En raison de la nature pratique de la sortie par défaut de RProgN, cela laisse le nombre, qui fait une boucle entre 1, 2 et 4, sur la première ligne et la version chaîne de la fonction sur la seconde. Inspiré par la réponse Python de @LeakyNun

Essayez-le en ligne!

CJam , 17 octets

{sZZe\6Ye\"_~"}_~

{s6Ze\ZYe\"_~"}_~

{sZ6e\ZYe\"_~"}_~

Essayez-le en ligne!

Probablement pas optimal, mais c'est une modification de mon approche du défi précédent .

L'idée de base est la même, mais nous effectuons deux swaps, dont l'un est toujours un no-op. Les indices concernés sont 2, 3et 6:

1:     {sZZe\6Ye\"_~"}_~
ZZe\             does nothing
       {sZZe\6Ye\"_~"}_~
6Ye\     \   /
          \ /
           X
          / \
         /   \
2:     {s6Ze\ZYe\"_~"}_~
6Ze\      \  /
           \/    doesn't really do anything
           /\
          /  \
       {s6Ze\ZYe\"_~"}_~
ZYe\     \/
         /\
3:     {sZ6e\ZYe\"_~"}_~
Z6e\      \  /
           \/
           /\
          /  \
       {sZZe\6Ye\"_~"}_~
ZYe\     \/      doesn't really do anything 
         /\
1:     {sZZe\6Ye\"_~"}_~

CJam , 14 octets

{_]3/W="_~"}_~

{_]3/W="_~"}{_]3/W="_~"}_~

{_]3/W="_~"}{_]3/W="_~"}{_]3/W="_~"}_~

Essayez-le en ligne!

Les autres programmes font respectivement 26 et 38 octets.

Explication

Encore une autre approche!

{       e# Again, the usual quine framework. In this case, there might
        e# be one or two additional copies of the block on the stack.
  _     e#   Duplicate the top copy of the block.
  ]     e#   Wrap all copies in an array.
  3/    e#   Split into chunks of 3. For the first two programs, this will
        e#   just wrap all of them in an array. For the third program, this
        e#   splits the fourth copy off from the first three.
  W=    e#   Select the last chunk. So `3/W=` does nothing for the first
        e#   two programs, but discards three copies once we get to four.
  "_~"  e#   Push the remainder of the program.
}_~

Gelée , 11 octets

“Ḥ%7Øv;”Ṙv1

Cela a généré le même programme avec 1 remplacé par 2 , qui a remplacé 2 par 4 , ce qui génère le programme d'origine.

Essayez-le en ligne!

Python 3, 127, 127 et 127 octets

a='a=%r;b=%r;c=%r;print(b%%(b,a,c))';b='b=%r;a=%r;c=%r;print(c%%(c,a,b))';c='c=%r;a=%r;b=%r;print(a%%(a,b,c))';print(b%(b,a,c))

impressions

b='b=%r;a=%r;c=%r;print(c%%(c,a,b))';a='a=%r;b=%r;c=%r;print(b%%(b,a,c))';c='c=%r;a=%r;b=%r;print(a%%(a,b,c))';print(c%(c,a,b))

impressions

c='c=%r;a=%r;b=%r;print(a%%(a,b,c))';a='a=%r;b=%r;c=%r;print(b%%(b,a,c))';b='b=%r;a=%r;c=%r;print(c%%(c,a,b))';print(a%(a,b,c))

Ceci est basé sur ma réponse à la question Interquine, qui est basée sur un quine Python normal. Et je sais exactement quoi faire quand on a une question quadri-interquine;)

CJam , 14 octets

0{\)3%\"_~"}_~

1{\)3%\"_~"}_~

2{\)3%\"_~"}_~

Essayez-le en ligne!

Explication

0{      e# Again, the standard CJam quine framework, but this time we have a zero
        e# at the bottom of the stack.
  \     e#   Bring the 0 to the top.
  )     e#   Increment.
  3%    e#   Mod 3 to loop from 2 back to 0.
  \     e#   Put the result underneath the block again.
  "_~"  e#   Push the remainder of the source.
}_~

Javascript (ES6), 63 55 octets

eval(c="`eval(c=${JSON.stringify(c)},n=${++n%3})`",n=0)

eval(c="`eval(c=${JSON.stringify(c)},n=${++n%3})`",n=1)

eval(c="`eval(c=${JSON.stringify(c)},n=${++n%3})`",n=2)

o1.innerText = eval(c="`eval(c=${JSON.stringify(c)},n=${++n%3})`",n=0) 
o2.innerText = eval(c="`eval(c=${JSON.stringify(c)},n=${++n%3})`",n=1)
o3.innerText = eval(c="`eval(c=${JSON.stringify(c)},n=${++n%3})`",n=2)

<pre id="o1"></pre>
<pre id="o2"></pre>
<pre id="o3"></pre>

Solution alternative utilisant Function.prototype.toString(tricheur, 30 octets)

(f=n=>`(f=${f})(${++n%3})`)(1)

Lambda Calculus , 38 caractères, 44 octets

Une solution simple basée sur la mère de toutes les quines: le combinateur y :

(λx.(λy.y)(λz.z)xx)(λx.(λy.y)(λz.z)xx)

En utilisant les réductions bêta, nous voyons qu'il s'agit bien d'une tri-interquine:

(λx.(λy.y)(λz.z)xx)(λx.(λy.y)(λz.z)xx)
(λy.y)(λz.z)(λx.(λy.y)(λz.z)xx)(λx.(λy.y)(λz.z)xx)
(λz.z)(λx.(λy.y)(λz.z)xx)(λx.(λy.y)(λz.z)xx)
(λx.(λy.y)(λz.z)xx)(λx.(λy.y)(λz.z)xx)
etc.

Java 8, 118 octets

v->{int i=0;String s="v->{int i=%d;String s=%c%s%2$c;return s.format(s,++i%%3,34,s);}";return s.format(s,++i%3,34,s);}

Seule int i=0;est la différence entre les fonctions / sorties (c'est soit 0, 1soit 2).

Explication:

Essayez-le en ligne.

v->{                       // Method with empty unused parameter and String return-type
  int i=0;                 //  Integer, starting at 0, 1 or 2 depending on the version
                           //  (this is the only variation between the functions/outputs)
  String s="v->{int i=%d;String s=%c%s%2$c;return s.format(s,++i%%3,34,s);}";
                           //  String containing the unformatted source code
  return s.format(s,++i%3,s);}
                           //  Quine to get the source code, which we return as result
                           //  ++i%3 is used to cycle 0→1→2→0

Explication supplémentaire:

quine -part:

• String s contient le code source non formaté
• %s est utilisé pour mettre cette chaîne en elle-même avec s.format(...)
• %c, %2$cEt 34sont utilisés pour formater les guillemets doubles ( ")
• %%est utilisé pour formater le signe modulo ( %)
• s.format(s,...,34,s) met tout cela ensemble

Différence des sorties / fonctions:

Même approche que la plupart des autres réponses:

• int icommence soit 0, 1soit2
• ++i%3transforme ce à l'autre ( 0→1; 1→2; 2→0)

> <> , 15 octets

1'~r2*7%nd3*>o<

Essayez-le en ligne!

Utilise la même forme générale que les autres quines> <>, mais a un caractère supplémentaire devant qui passe par 1, 2 et 4.