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

Bedarf:

• Nur eine Sprache für beide Programme
• Programme sind unterschiedlich. Ein Programm, das sich selbst ausgibt, ist nicht qualifiziert.
• Beide Programme sind nicht leer oder mindestens 1 Byte lang. Nachgestellte Zeilenumbrüche sowohl in der Quelle als auch in der Ausgabe werden ignoriert
• stdin ist geschlossen. Lesen Sie nichts ( Sie können die Quelle also nicht lesen und manipulieren). Die Ausgabe erfolgt nach stdout.
  Edit: stdin ist verbunden mit /dev/null. Sie können bestellen, dass es geschlossen ist, wenn dies geklärt ist.
• Verwenden Sie keine randomFunktionen.

Zusätzlich:

• Erklärungen geben, wenn möglich

Punktzahl ist die Gesamtlänge . Der nachgestellte Zeilenumbruch zählt nicht, wenn er das Programm nicht beeinflusst.

CJam , 13 + 13 = 26 Bytes

{sYZe\"_~"}_~

Probieren Sie es online!

Ausgänge

{sZYe\"_~"}_~

Erläuterung

{       e# Standard quine framework, leaves a copy of the block on the stack
        e# for the block itself to process.
  s     e# Stringify the block.
  YZe\  e# Swap the characters at indices 2 and 3, which are Y and Z themselves.
  "_~"  e# Push the "_~" to complete the quine.
}_~

Da e\es in seinem zweiten und dritten Operanden kommutativ ist, macht das andere Programm genau dasselbe Zund wechselt Yin die ursprüngliche Reihenfolge.

CJam ,11 + 13 = 24 11 + 12 = 23 Bytes

"N^_p"
N^_p

Probieren Sie es online!

Ausgänge:

"N^_p
"
N^_p

Die Ausgabe hat 13 Bytes, aber:

Der nachgestellte Zeilenumbruch zählt nicht, wenn er das Programm nicht beeinflusst.

Also habe ich das Leerzeichen in eine neue Zeile geändert, um das auszunutzen.

Es basiert auf dem kürzesten CJam-Quine:

"_p"
_p

Und N^besteht darin, die Zeichenfolge mit einer neuen Zeile zu versehen, die eine neue Zeile hinzufügt, wenn es keine neue Zeile gibt, und diese zu entfernen, wenn es eine Zeichenfolge gibt, bei der jedes Zeichen eindeutig ist.

Ich glaube, ich habe diese Quine in der Quine-Frage gesehen, konnte sie aber nicht finden.

RProgN 2 , 3 + 3 = 6 Bytes

Erstes Programm:

0
1

Probieren Sie es online!

Zweites Programm:

1
0

Probieren Sie es online!

-2 Danke an Martin Ender .

C, 95 + 95 = 190 Bytes

Vielen Dank an @immibis für das Speichern von 16 * 2 Bytes!

char*s="char*s=%c%s%c;main(i){i=%d^1;printf(s,34,s,34,i);}";main(i){i=1^1;printf(s,34,s,34,i);}

Probieren Sie es online!

Ausgänge:

char*s="char*s=%c%s%c;main(i){i=%d^1;printf(s,34,s,34,i);}";main(i){i=0^1;printf(s,34,s,34,i);}

Probieren Sie es online!

Welche Ausgänge:

char*s="char*s=%c%s%c;main(i){i=%d^1;printf(s,34,s,34,i);}";main(i){i=1^1;printf(s,34,s,34,i);}

Javascript, 67+67=134 bytes

1st program:

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

2nd program:

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

Dies basiert auf Herman Lauensteins Antwort auf Tri-Interquine

Javascript (ungültiger Quellcode), 75 + 75 = 150 61 + 61 = 122 58 + 58 = 116 50 + 50 = 100 Bytes

sparte 20 Bytes dank Tushar, 6 Bytes dank Craig Ayre und sparte 16 Bytes dank kamoroso94

1. Programm:

f=_=>alert(("f="+f).replace(0,a=>+!+a)+";f()");f()

2. Programm:

f=_=>alert(("f="+f).replace(1,a=>+!+a)+";f()");f()

Tauscht die 1 gegen die 0 und umgekehrt. Beide machen dasselbe und produzieren aufgrund ihres Quellcodes nur unterschiedliche Ausgaben.

Python 2, 63+63 = 126 bytes

Try it online

First program:

A='A=%r;print A[:23]%%A+A[29:35]23:29]';print A[:23]%A+A[23:29]

outputs:

A='A=%r;print A[:23]%%A+A[29:35]23:29]';print A[:23]%A+A[29:35]

Second program:

A='A=%r;print A[:23]%%A+A[29:35]23:29]';print A[:23]%A+A[29:35]

Outputs:

A='A=%r;print A[:23]%%A+A[29:35]23:29]';print A[:23]%A+A[23:29]

JavaScript (JsShell), 35 + 34 = 69 bytes

1:

(f=x=>print(`(f=${f})(${-x})`))(-1)

2:

(f=x=>print(`(f=${f})(${-x})`))(1)

Mathematica, 43 + 44 = 87 bytes

(Print[#1[#0[#1, -#2]]] & )[HoldForm, -1 1]

and

(Print[#1[#0[#1, -#2]]] & )[HoldForm, -(-1)]

asmutils sh, 16+16 bytes, abusing the "stdin is closed" rule.

#!/bin/sh
tr x y

Since stdin is closed and sh will open its script to the first available handle (rather than move it to a high numbered handle like modern shells do), tr ends up reading from a copy of the script without having ever opened it.

This interquine is payload capable but inserting a payload is tricky.

In addition, this original version abuses some crazy bug in the ancient kernel I used in those days. (I don't know what's up with that kernel--I found out later on it had different major and minor numbers for devices too.) If you fix the ABI changes that broke asmutils the interquine still won't work. I forget if asmutils sh has exec or not, but if it does, this is a modern version:

exec dd skip=0 | tr x y

This abuses a deliberate bug in asmutils dd; it has a performance optimization it calls llseek for skip if it can, but to save a byte it passes SEEK_SET rather than SEEK_CUR. This results in garbage on stderr but the interquine on stdout. Asmutils dd doesn't have an option to suppress the stderr spam.

Unterlast , 32 + 32 = 64 Bytes

(a~a*(:^)*S)(~(a)~a*^a(:^)**S):^

Probieren Sie es online!

(~(a)~a*^a(:^)**S)(a~a*(:^)*S):^

Probieren Sie es online!

Common Lisp, 58 Zeichen

#1=(let((*print-circle* t))(print'(write '#1# :circle t)))

... oder 24 Zeichen, wenn es Ihnen nichts ausmacht, wenn *print-circle*global festgelegt ist auf T:

#1=(print '(write '#1#))

Die gedruckte Darstellung des Codes wird als zyklische Struktur gelesen, wobei #1#auf die folgende Konsolenzelle zurückgegriffen wird #1=. Wir zitieren Programme, damit sie nicht ausgeführt werden. Da *print-circle*es T ist, achtet der REPL darauf, solche Leservariablen während des Druckens auszugeben. Dies ist, was der obige Code ausgibt und zurückgibt:

#1=(write '(print '#1#)) 

Wenn wir den obigen Code auswerten, gibt er Folgendes aus:

#1=(print '(write '#1#))

Wenn Sie den Standardwert für *print-circle*beibehalten möchten , der in einer konformen Implementierung NIL ist, müssen Sie die Variable vorübergehend neu binden:

#1=(let((*print-circle* t))(print'(write '#1# :circle t)))

Innerhalb des Körpers des LET drucken wir Dinge mit *print-circle*T. So erhalten wir:

#1=(write
    '(let ((*print-circle* t))
       (print '#1#))
    :circle t) 

Wie Sie sehen, wird das neue Programm nicht erneut gebunden *print-circle*, aber da wir writedie Low-Level-Funktion verwenden, die von aufgerufen wird print, können wir zusätzliche Argumente übergeben, wie z :circle. Der Code funktioniert dann wie erwartet:

#1=(let ((*print-circle* t))
     (print '(write '#1# :circle t)))

Allerdings müssen Sie die oben genannten Programme als Skript auszuführen, nicht in einem REPL, denn auch wenn man die Dinge drucken , während der Rundbauten die Pflege, die beide writeund printauch gibt den Wert gedruckt wird; und in einem Standard-REPL wird der Wert ebenfalls gedruckt, jedoch außerhalb des dynamischen Kontexts, in dem *print-circle*T steht.

> <> , 16 + 16 = 32 Bytes

":1-}80.r   !#o#

und

#o#!   r.08}-1:"

Probieren Sie es online!

Dies funktioniert durch einen Sprung im Programm. Der erste Programmsprung überspringt die Umkehrung des Stapels (wenn er den Stapel umkehrt, ist das ein Quine). Das zweite Programm überspringt nicht das Gegenteil, aber wurde es bereits durch den Programmfluss umgekehrt, wird das Original erstellt.

Dieser Code endet mit einem Fehler.

RProgN 2 , 7 + 7 = 14 Bytes

Ich wollte versuchen, eine bessere Nutzung von RProgN zu demonstrieren, anstatt nur Druckaufträge zu missbrauchen ...

1
«\1\-

und...

0
«\1\-

Erklärt

1   # Push the constant, 1. (Or 0, depending on the program)

«\1\-
«       # Define a function from this to the matching », in this case there isn't any, so define it from this to the end of the program, then continue processing.
 \      # Flip the defined function under the constant.
  1\-   # Get 1 - Constant.

Da hierdurch der Stapel verkehrt herum gedruckt wird, wird zuerst die neue Konstante und dann die stringierte Version der Funktion gedruckt.

Probieren Sie es online!

LOGO , 65 + 66 = 131 Bytes

apply [(pr ? ` [[,? ,-?2]] )] [[apply [(pr ? ` [[,? ,-?2]] )]] 1]

und

apply [(pr ? ` [[,? ,-?2]] )] [[apply [(pr ? ` [[,? ,-?2]] )]] -1]

Python 3, 74 + 74 = 148 Bytes

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

und

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

Ich verstehe es auch nicht

> <> , 12 + 12 = 24 Bytes

'3d*!|o|!-c:

und

':c-!|o|!*d3

Probieren Sie es online!

Beide Programme verwenden ein Wrapping-String-Literal, um den Code zum Stapel hinzuzufügen, und erstellen dann den 'Befehl mit verschiedenen Methoden. Beim Drucken des Stapels wird der Code nach hinten gedrückt, der Stapel 'bleibt jedoch vorne. Es gibt verschiedene Variationen, die das produzieren '; 3d*, d3*, 00g, :c-Wenn gepaart mit 3d*und:9- wenn gepaart mit00g .

Eine zu ähnliche Lösung zum Posten, in Befunge-98 für 13 * 2 Bytes

"2+ck, @,kc+2

Stax , 18 + 20 = 38 Bytes

"Vn|^34bL"Vn|^34bL

Online ausführen und debuggen!

"Vn|^34bL
"Vn|^34bL

Online ausführen und debuggen!

Erläuterung

Der Vollständigkeit halber hinzugefügt. Port von @ jimmy23013s CJam-Antwort. Schaltet die Zeilenumbrüche mit set xor um.

Javascript (ES6), 36 + 36 = 72 Bytes

Programm 1:

f=n=>('f='+f).replace(/4|5/g,n=>n^1)

Programm 2:

f=n=>('f='+f).replace(/5|4/g,n=>n^1)

Diese Programme klonen sich selbst und ersetzen 5mit 4und 4mit5

console.log((
    f=n=>('f='+f).replace(/4|5/g,n=>n^1)
)())
console.log((
    f=n=>('f='+f).replace(/5|4/g,n=>n^1)
)())

Klein , 26 24 Bytes

<:3+@+3<:"

Probieren Sie es online!

Erläuterung

Dies funktioniert genauso wie bei meinem Klein Quine , bei dem die Quelle rückwärts gefolgt von einem ausgedruckt wird ". Das letzte Mal wurde dies durch Palindromie behoben. Wir müssen es also nicht palindromisieren, ohne die Funktionalität zu beeinträchtigen. Durch die Umstellung <und :wir konnten dies mit Funktionalität , ohne sich zu tun.

Pari / GP , 36 + 36 = 72 Bytes

(f=(x)->print1("(f="f")("1-x")"))(1)

Probieren Sie es online!

(f=(x)->print1("(f="f")("1-x")"))(0)

Probieren Sie es online!