In den vorherigen Abenteuern der Quine-Blogserie haben wir untersucht, wie wir unsere eigenen Quines und Introns schreiben. Heute werden wir sehen, was QuineRelays sind und wie Sie Introns nutzen können, um sie zu erstellen.
Stellen Sie sich eine Reihe von Programmen vor, die jeweils in einer anderen Sprache geschrieben sind. Jedes Programm in diesem Kreis hat einen einzigen Zweck: den Quellcode des nächsten Programms in der Sequenz zu drucken. Das letzte Programm schließt dann die Schleife, indem es den Quellcode des allerersten Programms ausgibt.
Im Wesentlichen handelt es sich bei QuineRelays um eine Reihe von n Programmen in n verschiedenen Sprachen, sodass:
Sehen wir uns einige Beispiele an, um das Konzept besser zu verstehen.
Dieses QuineRelay 2. Ordnung verfügt über ein JavaScript-Programm, das ein Python-Programm druckt, das dann das ursprüngliche JavaScript-Programm zurückdruckt. Es ist ein dynamisches Duo der Selbstreplikation.
JavaScript → Python ⥀
JavaScript: Probieren Sie es online aus!
console.log((q=_=>`print(${JSON.stringify(`console.log((q=${q+[]})())`)})`)())
Python: Probieren Sie es online aus!
print("console.log((q=_=>`print(${JSON.stringify(`console.log((q=${q+[]})())`)})`)())")
Noch interessanter wird es mit einem QuineRelay 3. Ordnung. Dieses beginnt mit einem Haskell-Programm, das ein Python-Programm ausgibt, das ein Ruby-Programm ausgibt, und schließlich kehrt das Ruby-Programm zum ursprünglichen Haskell-Programm zurück.
Haskell → Python2 → Ruby ⥀
Haskell: Probieren Sie es online aus!
q a b c=putStrLn $ b ++ [toEnum 10,'q','('] ++ show b ++ [','] ++ show c ++ [','] ++ show a ++ [')']
main=q "q a b c=putStrLn $ b ++ [toEnum 10,'q','('] ++ show b ++ [','] ++ show c ++ [','] ++ show a ++ [')']" "def q(a,b,c):print b+chr(10)+'q('+repr(b)+','+repr(c)+','+repr(a)+')'" "def e(x) return 34.chr+x+34.chr end;def q(a,b,c) print b+10.chr+'main=q '+e(b)+' '+e(c)+' '+e(a)+' '+10.chr end"
Python2: Probieren Sie es online aus!
def q(a,b,c):print b+chr(10)+'q('+repr(b)+','+repr(c)+','+repr(a)+')'
q("def q(a,b,c):print b+chr(10)+'q('+repr(b)+','+repr(c)+','+repr(a)+')'","def e(x) return 34.chr+x+34.chr end;def q(a,b,c) print b+10.chr+'main=q '+e(b)+' '+e(c)+' '+e(a)+' '+10.chr end","q a b c=putStrLn $ b ++ [toEnum 10,'q','('] ++ show b ++ [','] ++ show c ++ [','] ++ show a ++ [')']")
Ruby: Probieren Sie es online aus!
def e(x) return 34.chr+x+34.chr end;def q(a,b,c) print b+10.chr+'main=q '+e(b)+' '+e(c)+' '+e(a)+' '+10.chr end
q("def e(x) return 34.chr+x+34.chr end;def q(a,b,c) print b+10.chr+'main=q '+e(b)+' '+e(c)+' '+e(a)+' '+10.chr end","q a b c=putStrLn $ b ++ [toEnum 10,'q','('] ++ show b ++ [','] ++ show c ++ [','] ++ show a ++ [')']","def q(a,b,c):print b+chr(10)+'q('+repr(b)+','+repr(c)+','+repr(a)+')'")
Hier ist ein QuineRelay 4. Ordnung: Ruby → Java → C# → Python ⥀
GitHub
Kulturübergreifend gibt es mehrere gemeinsame Symboliken. Einer von ihnen ist der Ouroboros, der Bezüge in der ägyptischen, griechischen, römischen, hinduistischen, sibirischen, nordischen, afrikanischen und südamerikanischen Mythologie hat. Der Ouroboros ist ein altes Symbol, das eine Schlange oder einen Drachen darstellt, der seinen eigenen Schwanz verschlingt und den ewigen Kreislauf von Schöpfung und Zerstörung darstellt.
In der nordischen Mythologie ist Jörmungandr eine kolossale Schlange, das mittlere Kind von Loki und der Riesin Angrboða. Odin warf Jörmungandr in den Ozean um Midgard (das Reich der Menschen), wo die Schlange so groß wurde, dass sie die Welt umkreiste und ihren eigenen Schwanz ergriff. Da sie Midgard (die Erde) umgibt, wird sie als Weltenschlange – Ouroboros – bezeichnet. Dass Jörmungandr seinen Schwanz loslässt, ist eines der Zeichen für den Beginn von Ragnarök (der letzten Schlacht der Welt).
Quine-Relais verkörpern diese Symbolik sehr gut, da jedes Programm im Zyklus das nächste hervorbringt, nur um am Ende wiedergeboren zu werden, und tragen daher den Spitznamen Ouroboros Programme.
Behalten Sie Ihre Plätze. Hier ist ein Ouroboros QuineRelay 128. Ordnung. Ja, das hast du richtig gelesen. 128 !!!
Ruby → Rust → Scala → ... (120 andere) ... → Python → R → Ratfor → rc → REXX ⥀
GitHub
Als ob das nicht beeindruckend genug wäre, gibt es noch ein Osterei. Der ursprüngliche Ruby-Code enthält im verkleinerten Zustand einen Ouroboros-Drachen!
Beginnen wir mit dem Python-Intron, das wir zuvor geschrieben haben, und versuchen wir, es in ein QuineRelay 2. Ordnung umzuwandeln.
Python Intron: Probieren Sie es online aus!
intron = 'wubbalubbadubdub'
data = "print('intron =', repr(intron)); print('data =', repr(data)); print(data)"
print('intron =', repr(intron)); print('data =', repr(data)); print(data)
Mit der Magie der Introns können wir jetzt ganz einfach den Code-Teil eines Geschwister-Quine einer anderen Sprache in das Intron einfügen. Erstellen eines Programms der Form:
Python:
intron = "code part of sibling"
data = "code part of self"
print('intron =', repr(intron)); print('data =', repr(data)); print(data)
Da jede Variable einfach als Daten eines anderen Quine fungiert. Benennen wir data und intron in d1 bzw. d2 um.
Python:
d1 = "code part of self"
d2 = "code part of sibling"
print('d1 =', repr(d1)); print('d2 =', repr(d2)); print(d1)
Jetzt fungiert d2 als Intron, aber das obige Programm hat immer noch versucht, einen Codeteil von self zu drucken. Damit die Quelle des nächsten gedruckt wird, drucken wir am Ende (d2) anstelle von print(d1).
Python:
d1 = "code part of self"
d2 = "code part of sibling"
print('d1 =', repr(d1)); print('d2 =', repr(d2)); print(d2)
Wir wissen bereits, dass der Inhalt von d1 nur eine Kopie von Zeile 3 ist. Aber wir haben noch nicht den Inhalt von d2.
Angenommen, wir wollten ein QuineRelay mit JavaScript erstellen. Schreiben wir ein ähnliches Intron in JS.
JavaScript:
d1 = "code part of sibling"
d2 = "code part of self"
console.log(`d1 = ${JSON.stringify(d1)}`); console.log(`d2 = ${JSON.stringify(d2)}`); console.log(d1);
Nun, Zeile 3 des obigen JS-Introns ist der Code des Geschwisterprogramms, das wir wollten!
Fügen Sie den Code des anderen als Introns in den anderen ein.
Notiz. Wir müssen d1 + '' in js hinzufügen, um einige Nichtübereinstimmungen bei den Anführungszeichen zu vermeiden
Python: Try it online!
d1 = "print('d1 =', repr(d1)); print('d2 =', repr(d2)); print(d2)"
d2 = "console.log(`d1 = ${JSON.stringify(d1)}`); console.log(`d2 = ${JSON.stringify(d2)}`); console.log(d1 + '');"
print('d1 =', repr(d1)); print('d2 =', repr(d2)); print(d2)
JavaScript: Try it online!
d1 = "print('d1 =', repr(d1)); print('d2 =', repr(d2)); print(d2)"
d2 = "console.log(`d1 = ${JSON.stringify(d1)}`); console.log(`d2 = ${JSON.stringify(d2)}`); console.log(d1 + '');"
console.log(`d1 = ${JSON.stringify(d1)}`); console.log(`d2 = ${JSON.stringify(d2)}`); console.log(d1 + '');
There you go. It's a proper 2nd order QuineRelay! A Python program, that prints a JavaScript program, that prints the original Python program back in a cycle.
Creating a QuineRelay is an exercise in creative coding and understanding how different languages represent and manipulate strings. It involves weaving together introns from various programs, each containing the code to replicate its next neighbour.
At its core, an nth-order relay is a game of n clever ways to escape quotes across n programming languages.
Stay tuned for the next post on MultiQuine!
Sources and references:
Das obige ist der detaillierte Inhalt vonQuineRelay: Geburt der Quine-Schlange. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
