Verwandte: Interquine

Programm A gibt den Code von Programm B aus, wenn es ausgeführt wird, und B gibt die Quelle von C aus und C gibt die Quelle von A aus.

Dieses Mal können Sie nicht zwei Zeichen austauschen und erneut austauschen :)

Bedarf:

• Nur eine Sprache in allen Programmen
• Es gelten Standardlückenbeschränkungen
• Alle Programme sind unterschiedlich. Ein Programm, das sich selbst ausgibt, ist nicht qualifiziert. Zwei, die sich gegenseitig ausgeben, sind ebenfalls nicht qualifiziert.
• Alle Programme sind nicht leer oder mindestens 1 Byte lang.
• Es gibt nichts zu lesen, da stdin mit verbunden ist /dev/null(Sie können diese Regel missbrauchen, wenn Sie können ). Die Ausgabe geht an stdout.
• Verwenden Sie keine Funktionen, die zufällige Ergebnisse generieren.

Zusätzlich:

• Geben Sie nach Möglichkeit Erklärungen

Die Punktzahl ist die Länge der kürzesten (können Sie aus einer kurzen ein langes Programm erstellen?). Bitte schreiben Sie die Länge aller Programme und markieren Sie die kleinste Zahl. Nachgestellte Zeilenumbrüche zählen nicht. Die niedrigste Punktzahl gewinnt .

Python 3 , 50 Bytes

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

Probieren Sie es online aus!

Der letzte Ausdruck geht von 1*2%7bis 2*2%7nach 4*2%7dann zurück zu 1*2%7.

RProgN 2 , 12 8 Bytes

1
«\2*7%

Erklärt

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.

Aufgrund der praktischen Art und Weise, wie RProgN standardmäßig ausgegeben wird, verbleibt in der ersten Zeile die Zahl zwischen 1, 2 und 4 und in der zweiten Zeile die stringifizierte Version der Funktion. Inspiriert von @LeakyNun ‚s Python Antwort

Probieren Sie es online aus!

CJam , 17 Bytes

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

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

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

Probieren Sie es online aus!

Wahrscheinlich nicht optimal, aber dies ist eine Modifikation meiner Herangehensweise an die vorherige Herausforderung .

Die Grundidee ist dieselbe, aber wir führen zwei Swaps durch, von denen einer immer ein No-Op ist. Die betroffenen Indizes sind 2, 3und 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 Bytes

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

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

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

Probieren Sie es online aus!

Die anderen Programme sind 26 bzw. 38 Byte lang.

Erläuterung

Noch ein Ansatz!

{       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.
}_~

Gelee , 11 Bytes

“Ḥ%7Øv;”Ṙv1

Dies erzeugte das gleiche Programm, wobei 1 durch 2 ersetzt wurde , wodurch 2 durch 4 ersetzt wurde , wodurch das ursprüngliche Programm erzeugt wurde.

Probieren Sie es online aus!

Python 3, 127, 127 und 127 Bytes

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

druckt

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

druckt

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

Dies basiert auf meiner Antwort auf die Interquine-Frage, die auf einem normalen Python-Quine basiert. Und ich weiß genau, was zu tun ist, wenn wir eine Quad-Interquine-Frage bekommen;)

CJam , 14 Bytes

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

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

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

Probieren Sie es online aus!

Erläuterung

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 Bytes

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>

Alternative Lösung mit Function.prototype.toString(betrügerisch, 30 Bytes)

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

Lambda-Kalkül , 38 Zeichen, 44 Bytes

Eine einfache Lösung basierend auf der Mutter aller Quines: der y-Kombinator :

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

Anhand von Beta-Reduktionen sehen wir, dass dies tatsächlich ein Tri-Interquine ist:

(λ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 Bytes

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

Nur int i=0;ist der Unterschied zwischen den Funktionen / Ausgänge (es ist entweder 0, 1oder 2).

Erläuterung:

Probieren Sie es online aus.

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

Zusätzliche Erklärung:

Quine-Teil :

• String s enthält den unformatierten Quellcode
• %s wird verwendet, um diesen String mit sich selbst in sich zu setzen s.format(...)
• %c, %2$cUnd 34werden verwendet , um die doppelten Anführungszeichen zu formatieren ( ")
• %%wird verwendet, um das Modulo-Zeichen ( %) zu formatieren
• s.format(s,...,34,s) fasst alles zusammen

Unterschied der Ausgänge / Funktionen:

Gleicher Ansatz wie die meisten anderen Antworten:

• int ibeginnt entweder 0bei 1oder2
• ++i%3wandelt diese in die nächste ( 0→1; 1→2; 2→0)

> <> , 15 Bytes

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

Probieren Sie es online aus!

Verwendet dieselbe allgemeine Form wie andere> <> Quines, hat jedoch einen zusätzlichen Charakter vor sich, der durch 1, 2 und 4 geführt wird.