Zielsetzung:

Codieren Sie zwei Programme, bei denen jedes Programm beide Quellcodes ausgibt, die pro Zeichen verschachtelt sind, wie ein Reißverschluss, ein Quine mit zwei Schlitzen. Die Ausgabe eines Double-Slit-Quine beginnt mit dem ersten Zeichen aus dem Quellcode des ersten Programms. Wenn der Quellcode eines der Programme kürzer als der des anderen ist, muss der Rest der Ausgabe mit dem Rest des längeren Quellcodes gefüllt werden.

Regeln:

1. Sie können für beide Programme eine beliebige Programmiersprache verwenden, wobei für beide nicht dieselbe Programmiersprache erforderlich ist.
2. Ihre Programme sollten keine Eingaben von einer Datei, einem Dateinamen, einem Netzwerk, dem anderen Programm oder etwas anderem übernehmen.

Obligatorische Kriterien:

• Es gibt einen Haken, irgendwo in der Ausgabe muss das Wort QUINEin Großbuchstaben ununterbrochen existieren.
• Sie müssen angeben, welche zwei Programmiersprachen Sie verwenden. Wenn Sie für beide dieselbe Programmiersprache verwenden, müssen Sie nur eine Programmiersprache angeben.
• Beide Programme sollten unabhängig vom anderen Programm ausgeführt bzw. interpretiert werden können.

Beispiel:

Mit diesem Beispielquellcode von Programm eins :

"QIE"

Mit diesem Beispielquellcode von Programm zwei :

"UN"

Dann muss die gültige Double-Slit-Quine-Ausgabe beider Programme sein:

""QUINE""

Dies ist Code-Golf, die kleinsten Bytes beim Summieren der Länge beider Quellcodes und natürlich auch der Länge jedes ausgegebenen Programms gewinnen!

CJam, 49 47 Bytes

{`:_"__~~e#QUINE"}_~

und

{`:_"__~~e#QUINE"}_~e#QUINE

beide drucken

{{``""__~~""++::__""ee##QQUUIINNEE""}}__~~e#QUINE

Probieren Sie es online aus: Programm 1 , Programm 2 , Gültigkeitsnachweis

Wie sie arbeiten

{                }   e# Push a code block.
                  _~ e# Execute a copy.
 `                   e# Convert the code block into a string.
  :_                 e# Duplicate each character of the resulting string.
    "__~~e#QUINE"    e# Push this string.

Programm 1 endet hier und enthält eine Zeichenfolgendarstellung des gesamten Quellcodes (der jedes Zeichen zweimal wiederholt) sowie die Zeichenfolge e # QUINE auf dem Stapel.

Programm 2 analysiert zusätzlich e#QUINE, was ein Kommentar ist.

In beiden Fällen druckt CJam die beiden Zeichenfolgen automatisch aus, was zu der oben genannten Ausgabe führt.

Im Ernst, 46 56 42 Bytes

QUNX;RZtdXεj.ƒ£REIQ

Hex Dump:

51554e583b525a746458ee6a2e7f9f9c524549510a

Das zweite Programm ist genau dieses umgekehrte Programm. Es enthält zwar ein unsichtbares Zeichen, aber die Anzahl der Bytes ist korrekt. Beide Programme geben diese palindromische Zeichenfolge aus:

QQUINEXR;£RƒZ⌂t.djXεεXjd.t⌂ZƒR£;RXENIUQQ

(Aus irgendeinem Grund wird das unsichtbare Zeichen angezeigt, wenn es in meinem Terminal ausgegeben wird. Ich verstehe dieses 7F-Byte nicht wirklich.)

Wie es funktioniert:

Q                     Push the source to the stack
 U                    Nop
  NX                  Push and pop lyrics to 99 bottles of beer
    ;R                Make a copy of the source reversed.
      Z               Zip them together.
       t              Completely flatten the list.
        dX            Delete the trailing newline
          εj          Join it into a string.
            .         Print it with a trailing newline.
             ⌂        (This is that 7F byte that won't show up. It halts.)

Der Rest des Programms wird nicht ausgeführt.

Dann die andere Richtung:

\n                   Nop
  Q                  Push the source code.
   IE                Nops
     R               Reverse source code to get source of first program
      £              Eval it into a function
       ƒ             Call it.

Zu diesem Zeitpunkt führen wir jetzt das erste Programm oben aus, sodass die Ausführung wie dort beschrieben fortgesetzt wird.

Ich nutze die Tatsache stark aus, dass mehrere Befehle hier nichts mit Strings oder leeren Stapeln zu tun haben. Ich nutze auch das unerwartete Verhalten aus, twenn sich nur ein Element auf dem Stapel befindet. Erwarten Sie nicht, dass dieses Programm in zukünftigen Versionen von Seriously funktioniert.

Da die Online-Version des Seriously-Interpreters weiterhin fehlerhaft ist, müssen Sie den Interpreter herunterladen und auf Ihrem eigenen Computer ausführen, um ihn zu testen.

GolfScript, 46 Bytes

{`{.}%"..~~QUINE"}.~

und

{`{.}%"..~~QUINE"}.~QUINE

beide drucken

{{``{{..}}%%""....~~~~QQUUIINNEE""}}..~~QUINE

Probieren Sie es online aus: Programm 1 , Programm 2 , Gültigkeitsnachweis

Wie es funktioniert

{`{.}%"..~~QUINE"}.~

{                }    # Push a code block.
                  .~  # Execute a copy.
 `                    # Convert the code block into a string.
  {.}%                # Duplicate each character of the resulting string.
      "..~~QUINE"     # Push that string.

Der Quellcode von Programm 2 analysiert zusätzlich QUINE\nzwei undefinierte Token.

Perl, 61 + 60 = 121 Bytes

Programm 1:

$x=q<print"\$x=q<$x>;eval\$x#"=~s/./$&$&/gr,QUINE>;eval$x#QIE

Programm 2:

$x=q<print"\$x=q<$x>;eval\$x#"=~s/./$&$&/gr,QUINE>;eval$x#UN

Ich dachte, ich würde es in einer Sprache ohne Golf versuchen. Dies ist im Grunde nur ein universeller Quine-Konstruktor in Perl, der so modifiziert wurde, dass jedes Zeichen vor dem Drucken verdoppelt und QUINEan das Ende angehängt wird . Dann müssen wir nur noch einen Kommentar am Ende des Codes einfügen, um den hinzugefügten Text zu kompensieren.

(Ich habe dies geschrieben, ohne wirklich auf die anderen Antworten zu achten. Es stellte sich heraus, dass es möglich wäre, ein Byte zu speichern, indem der gesamte Kommentar in ein Programm eingefügt wird, aber ich bin mir nicht sicher, ob ich solche Algorithmen einfach krass kopieren sollte.)