Die Herausforderung

In dieser Herausforderung geben Sie eine Quellsprache S und eine Zielsprache an T . Ihre Aufgabe ist es, das folgende Programm Pin der Sprache zu schreiben S. Wenn ein gültiges Programm Qin der Sprache Tals Eingabe für angegeben wird P, wird ein gültiges Programm Rin der Sprache ausgegeben, Tdas keine Ein- und Ausgaben vornimmt Q(R), dh das Programm, Qdas auf den Quellcode von angewendet wird R. Außerdem sollten Sie in Ihrer Antwort ein nicht triviales Beispielprogramm Q(je interessanter, desto besser, obwohl Sie dafür keine Punkte erzielen), das resultierende Programm Rund die Ausgabe von präsentieren R. Dies ist Code-Golf, also der kürzeste Code für PGewinne.

Mit anderen Worten, dies ist eine Herausforderung beim Schreiben eines "universellen Quine-Konstruktors", mit dem beliebige Arten von verallgemeinerten Quines erstellt werden können.

Klarstellungen

• Ihre Ausgangs- und Zielsprache sind möglicherweise identisch.
• Das Programm Psollte eine Zeichenfolge als Eingabe (von STDIN oder gleichwertig) und eine Zeichenfolge (an STDOUT oder gleichwertig) ausgeben, wie jedes Ausgabeprogramm R.
• Die Eingabeprogramme Qsollten auch eine Zeichenfolge in eine andere Zeichenfolge umwandeln, ihre Form ist jedoch flexibler: Dies können Zeichenfolge-zu-Zeichenfolge-Funktionen, Codeausschnitte sein, die eine Variable mit einem bestimmten Namen ändern, und Ausschnitte, die den Datenstapel ändern, wenn Ihre Zielsprache Sie können die Form der Q's auch weiter einschränken , indem Sie angeben, dass sie beispielsweise keine Kommentare enthalten dürfen. Sie müssen jedoch in der Lage sein, jede berechenbare Zeichenfolge-zu-Zeichenfolge-Funktion als Eingabeprogramm zu implementieren Q, und Sie müssen explizit angeben, wie sie funktionieren und welche weiteren Einschränkungen Sie ihnen auferlegen.
• Das Ausgabeprogramm Rsollte eigentlich eine (verallgemeinerte) Quine sein, daher darf es keine Eingaben (Benutzereingaben, Dateien usw.) lesen, sofern Qdies nicht der Fall ist.
• Standardlücken sind nicht zulässig.

Ein Beispiel

Angenommen, ich wähle Python als Ausgangssprache und Haskell als Zielsprache und fordere außerdem, dass das Eingabeprogramm eine einzeilige Definition einer String -> StringFunktion mit dem Namen ist f. Wenn ich das Saitenumkehrprogramm gebe

f x = reverse x

Als Eingabe für mein Python-Programm Pwird der Quellcode eines anderen Haskell-Programms ausgegeben R. Dieses Programm druckt den Quellcode von auf STDOUT R, jedoch in umgekehrter Reihenfolge . If Perhält die Identitätsfunktion

f x = x

als Eingabe ist das Ausgabeprogramm Rein Quine.

Quelle = Ziel = CJam, 19 17 16 Bytes

{`"_~"+}`)q\"_~"

Dies setzt voraus, dass das Q(in STDIN angegebene) Eingabeprogramm ein CJam-Snippet ist, das eine Zeichenfolge oben auf dem Stapel erwartet und eine weitere Zeichenfolge oben auf dem Stapel zurücklässt.

Teste es hier.

Beispiele

1. Die Identität wäre nur ein leerer Ausschnitt, so dass STDIN leere Drucke hinterlassen würde

   {`"_~"+}_~
   

   Welches ist die Standard-Quine, mit einem zusätzlichen +.

2. Um eine Zeichenfolge in CJam umzukehren, können Sie W%Folgendes verwenden:

   {`"_~"+W%}_~
   

   was wir laufen können, um zu erhalten

   ~_}%W+"~_"`{
   

3. Als drittes Beispiel, sagen wir ein Snippet verwenden , die eine Zeichenfolge mit Leerzeichen streut: ' *. Laufen Pwir damit als Input, bekommen wir

   {`"_~"+' *}_~
   

   was wiederum druckt

   { ` " _ ~ " + '   * } _ ~  
   

4. Es funktioniert jetzt auch, wenn QZeilenumbrüche enthalten sind (obwohl dies in CJam niemals erforderlich ist). Hier ist ein Programm mit einem Zeilenumbruch, der alle Zeilenumbrüche aus einem String entfernt (auf unnötig verschlungene Weise - in Zeilen aufteilen, dann verbinden):

   N/
   ""
   *
   

   Daraus ergibt sich Folgendes R:

   {`"_~"+N/
   ""
   *}_~
   

   was wiederum druckt

   {`"_~"+N/""*}_~
   

Erläuterung

Schauen wir uns zuerst die produzierte Ausgabe an:

Die Standard-CJam-Quine ist

{`"_~"}_~

Es funktioniert wie folgt:

• Schieben Sie den Block {`"_~"}.
• Dupliziere es mit _.
• Führen Sie die Kopie mit aus ~.
• Verwandelt nun innerhalb des Blocks `den ersten Block in seine Zeichenfolgendarstellung.
• "_~" verschiebt die zwei Zeichen der Quelle, die nicht Teil des Blocks sind (und daher in der Zeichenfolgendarstellung fehlen).
• Die beiden Zeichenfolgen werden am Ende des Programms nacheinander gedruckt.

^{In der Basis-Quine `ist das unnötig, denn wenn Sie den Block einfach so lassen, wie er ist, wird er am Ende des Programms trotzdem gedruckt.}

Die Ausgabe meines Programms Pist eine modifizierte Version dieses Snippets. Zuerst habe ich +dem Block ein hinzugefügt , das die beiden Zeichenfolgen zu einer Zeichenfolge zusammenfasst, die die gesamte Quelle enthält. Beachten Sie, dass dies unabhängig von meiner Arbeit im Block der Fall ist, da dies alles zu der mit erhaltenen Zeichenfolgendarstellung hinzugefügt wird `. Jetzt kann ich einfach das Programm / Snippet Qin den Block nach dem einfügen +, damit es die Quellzeichenfolge modifizieren kann, bevor sie gedruckt wird. Da es Qin den Block geht, wird es wieder Teil der Quellzeichenfolge sein.

Zusammenfassend Pdruckt

{`"_~"+Q}_~

Nun, wie gehe ich vor, um diese Ausgabe zu konstruieren in P:

{`"_~"+}         "Push the block without Q.";
        `        "Turn it into a string. This is shorter than writing a string right away,
                  because I'd have to escape the quotes, and I'd need two quotes instead of
                  one backtick.";
         )       "Pop off the last character (the brace) and push it on the stack.";
          q      "Read input Q.";
           \     "Swap Q with the brace.";
            "_~" "Push the final two characters.";

Die vier Zeichenfolgen werden am Ende des Programms automatisch (hintereinander) gedruckt.

Haskell-Ausdrücke → Haskell-Ausdrücke, 41 Byte

((++)<*>show).('(':).(++")$(++)<*>show$")

Probieren Sie es online!

Wie es funktioniert

P $ "Q"= ((++)<*>show).('(':).(++")$(++)<*>show$") $ "Q"konstruiert "R"von

1. (++")$(++)<*>show$"): Anhängen der Zeichenfolge ")$(++)<*>show$",
2. ('(':): Voranstellen des Zeichens '('und
3. (++)<*>show(= \x->x++show x): Anhängen einer zitierten Version davon,

resultierend in "R"= "(Q)$(++)<*>show$\"(Q)$(++)<*>show$\"".

R= (Q)$(++)<*>show$"(Q)$(++)<*>show$"arbeitet von

1. die Schnur nehmen "(Q)$(++)<*>show$",
2. (++)<*>show: Anhängen einer zitierten Version davon,
3. auf das zutreffen Q,

resultierend in Q "(Q)$(++)<*>show$\"(Q)$(++)<*>show$\""= Q "R".

(Die Parens Qsind notwendig, weil Qsie $genauso leicht enthalten können wie es der RFall ist und $leider rechtsassoziativ ist.)

Demo

λ> putStrLn $ ((++)<*>show).('(':).(++")$(++)<*>show$") $ "id"
(id)$(++)<*>show$"(id)$(++)<*>show$"
λ> putStrLn $ (id)$(++)<*>show$"(id)$(++)<*>show$"
(id)$(++)<*>show$"(id)$(++)<*>show$"
λ> putStrLn $ ((++)<*>show).('(':).(++")$(++)<*>show$") $ "reverse"
(reverse)$(++)<*>show$"(reverse)$(++)<*>show$"
λ> putStrLn $ (reverse)$(++)<*>show$"(reverse)$(++)<*>show$"
"$wohs>*<)++($)esrever("$wohs>*<)++($)esrever(
λ> putStrLn $ ((++)<*>show).('(':).(++")$(++)<*>show$") $ "length"
(length)$(++)<*>show$"(length)$(++)<*>show$"
λ> print $ (length)$(++)<*>show$"(length)$(++)<*>show$"
44

Quelle = Ziel = JavaScript, 66

console.log("function a(){console.log("+prompt()+"(a+'a()'))}a()")

Annahmen für Q:

• Q sollte eine anonyme Zeichenfolge-zu-Zeichenfolge-JavaScript-Funktion sein.

Beispiele:

• Rückwärts . Q =function(s) { return s.split('').reverse().join(''); }

In diesem Fall ist P(Q)(oder R): function a(){console.log(function(s) { return s.split('').reverse().join(''); }(a+'a()'))}a()und wenn wir es ausführen, erhalten wir: )(a}))')(a'+a(} ;)''(nioj.)(esrever.)''(tilps.s nruter { )s(noitcnuf(gol.elosnoc{)(a noitcnufdas ist genau das Gleiche wie Q(R).

• Identität . Q =function(s) { return s; }

In diesem Fall ist P(Q)(oder R): function a(){console.log(function(s) { return s; }(a+'a()'))}a()eine JavaScript-Quine . Unnötig zu sagen, Q(R)wird das gleiche sein, da Q die Identitätsfunktion ist.

Einige Notizen:

STDIN in JavaScript ist traditionell prompt(), ich habe mir jedoch erlaubt, von der Tradition von alert()STDOUT abzusehen, um die Ausführung der Ausgabe als Programm mit Copy-Paste zu vereinfachen. (Ich weiß, dass ich bis zu 12 Zeichen speichern kann , wenn ich zu änderealert() .)

Ich kann die Dinge in ES6 auch viel kürzer machen, aber ich möchte vorerst bei Native JavaScript bleiben. Ich denke darüber nach, in Zukunft eine S = Scala, T = ECMA6 Antwort einzureichen, nur für die Erfahrung.

Mir ist auch klar, dass JavaScript CJam im Code-Golf fast nie schlagen kann , aber ich musste diese Herausforderung annehmen! Es war sicher lustig.

Gelee → 7 , 9 Bytes

“ṚƓ^ṾṂ’³3

Probieren Sie es online!

Q ist eine 7-Funktion (dh, sie geht nicht über das oberste Stack-Element hinaus und führt die E / A über den Stack aus) und wird als Befehlszeilenargument angegeben.

Erläuterung

Das 7 Programm

Der universelle Quine-Konstruktor in 7, den ich hier verwende, ist:

717162234430…3

Das Erste, was zu beachten ist, ist, dass die führende 7 das Äquivalent von führendem Leerzeichen ist und keine Auswirkung auf das Programm hat. Der einzige Grund, warum dies der Fall ist, besteht darin, die PPCG-Regeln gegen Quines zu befolgen (sie werden nicht von sich 1selbst, sondern von der Sekunde im Programm codiert ).

Der Rest des Programms ist ein einzelnes Stapelelement (es hat ein ausgeglichenes 7s und 6s), das beim Ausführen Folgendes ausführt:

717162234430…3
 1716           Push a stack element "7" onto the stack
     2          Copy it
      23        Pop and output one of the copies (selecting format 7)
        4430    Prepend it to the top of stack
             3  Output it

Mit anderen Worten, dieses Stack-Element ist ein Programm, das den Anfang des Stapels mit 7vorangestelltem Text im Ausgabeformat 7 druckt (was bedeutet, dass "wörtlich mit derselben Codierung wie der Quellcode gedruckt wird") und somit eindeutig die beste Codierung für ist Quinen). Hier ist es ein Glücksfall, dass wir das Literal 7für zwei Zwecke wiederverwenden können (das Ausgabeformat und das führende Leerzeichen.) Durch Einfügen von etwas direkt vor dem Finale 3können wir eindeutig eine Funktion 7der Eingabe ausgeben, anstatt nur die Ausgabe 7und das direkt eingeben.

Wie kommt dieses Stack-Element zu seinem eigenen Quellcode? Nun, wenn das Programmende erreicht ist, ist 7 evalstandardmäßig das oberste Stack-Element. Es ist jedoch nicht tatsächlich aus dem Stapel herausgesprungen, sodass das evalgeführte Stapelelementliteral immer noch vorhanden ist. (Mit anderen Worten, das Programm liest nicht seinen eigenen Quellcode, was durch die Tatsache belegt wird, dass es nicht in der Lage ist, das 7am Programmanfang stehende Trennzeichen zu sehen , das eher ein Stapelelement als ein Teil eines Buchstabens ist - sondern es besteht hauptsächlich aus einem Literal, evaldas standardmäßig geführt wird.)

Das Jelly-Programm

Dies ist vielleicht eines der am wenigsten Jelly-ähnlichen Jelly-Programme, die ich geschrieben habe. Es besteht aus drei nilads ( “ṚƓ^ṾṂ’, ³, 3), die nur in Ausgabefolge sind , da keine Operationen an ihnen durchgeführt werden. Das 3ist offensichtlich genug, nur eine ganzzahlige Konstante zu sein. Das ³ist auch einfach, wenn Sie Jelly kennen: Es ist Jellys explizite Notation für das erste Befehlszeilenargument (wo Jelly normalerweise seine Eingabe macht). Der Rest des Jelly-Programms stellt den Großteil meines 7 Universal Quine-Konstruktors dar. Indem wir die Tatsache ausnutzen, dass alle Befehle in 7 mit ASCII-Ziffern dargestellt werden können, können wir interpretieren717162234430nicht als Folge von Befehlen oder sogar als Oktalzahl (wie es konzeptionell ist), sondern als Dezimalzahl, was bedeutet, dass wir keine spezielle Formatierung für die Ausgabe benötigen. Diese Dezimalzahl wird “ṚƓ^ṾṂ’in Jellys komprimierter Ganzzahlnotation.

Beispiel

Wenn wir 24053als Programm Q angeben, erhalten wir die folgende Ausgabe:

717162234430240533

Probieren Sie es online!

2405 verkettet das oberste Stapelelement mit sich selbst:

2405   Stack   Explanation
       x
2      x|x     Duplicate top of stack
 4     x||x    Swap two stack elements, with an empty element between
  0    x|(X)   Escape the top stack element, then concatenate the top two
   5   xx      Execute the top stack element

(Der letzte Schritt sieht möglicherweise etwas verwirrend aus. Wenn Sie ein Stack-Element maskieren, wird jeder darin enthaltene Befehl von "Diesen Befehl ausführen" in "Diesen Befehl an den Anfang des Stapels anhängen" konvertiert, sodass jeder Befehl an das Original angehängt wird oberstes Stapelelement, während es läuft.)

Wenn Sie das resultierende Programm R ausführen, erhalten Sie zwei Kopien von R:

7171622344302405371716223443024053

CJam → CJam, 13 Bytes

{`"_~"+7}_~qt

Probieren Sie es online!

Die Eingabe Qsollte ein Codeausschnitt sein, der die einzige Zeichenfolge im Stapel ändert. Qwird von stdin gelesen.

Beispiel

Eingang:

S*W%

Es wird ein Leerzeichen zwischen zwei Zeichen eingefügt und die Zeichenfolge umgekehrt.

Ausgabe:

{`"_~"+S*W%}_~

Ausgabe der verallgemeinerten Quine:

~ _ } % W * S + " ~ _ " ` {

Erläuterung

{`"_~"+7}_~      e# Evaluate a generalized quine in CJam that only appends a 7.
q                e# Read the input.
t                e# Replace the 7th character (0-based) with the input.

Zunächst wird das Quine ausgewertet, damit wir seine Zeichenfolgendarstellung ohne unnötige doppelte Anführungszeichen erhalten. Ersetzen Sie dann die Nutzlast durch die Eingabe.

Es könnte sein, {`"_~"+ }_~7qtdass der Raum der Platzhalter der Nutzlast ist. Aber die Änderung der Nutzlast 7spart ein Byte.

Holzkohle → Perl (5), 29 33 Bytes

Ａ$_=q(αＡ);evalβαＳ"\α$_β\n";printβ

Probieren Sie es online!

Das Perl-Programm Q sollte ein Snippet zurückgeben, das die Eingabe als Zeichenfolge auf die rechte Seite nimmt und die Ausgabe in der Variablen bereitstellt $_. (Beliebige Perl-Funktionen können in dieses Formular konvertiert werden, indem sie wie sub x {…}; $_=xfolgt umbrochen werden . In den meisten Fällen bedeutet die Perl-Syntax jedoch, dass kein Umbruch erforderlich ist.)

Erläuterung

Die Perl

So sieht der universelle Perl-Quine-Konstruktor aus:

$_=q(…"\$_=q($_);eval";print);eval

(In den meisten Fällen würden Sie gerne Golf spielen $_=q(say…"\$_=q($_);eval");eval, aber ich bin mir nicht sicher, ob Sie darin beliebigen Perl-Code einfügen …können.)

Mit anderen Worten, wir haben einen äußeren Wrapper, $_=q(…);evalder eine Zeichenfolge zuweist$_ und dann auswertet. Innerhalb des Wrappers befindet "\$_=q($_);eval"sich also eine Rekonstruktion des Wrappers zusammen mit seinem Inhalt, indem der von uns gespeicherte Wert $_plus der vom Benutzer angegebene Code Q plus printdie Ausgabe gedruckt wird. (Leider können wir nicht verwenden say; es fügt eine neue Zeile hinzu, und das ist in Quines relevant.)

Die Holzkohle

Der "Sinn" dieser Antwort bestand darin, in Perl verallgemeinerte Quines zu erzeugen. Nachdem ich also eine Golfstrategie dafür entwickelt hatte (eine, die ich in vielen anderen Antworten verwendet habe), war es an der Zeit, das Programm P zu schreiben, das im Grunde genommen nur Ersatz ist eine Zeichenfolge in eine Vorlage. Was ich hier wollte, war eine Sprache, die gut darin war, konstante Zeichenfolgen zu drucken (im Idealfall ein wenig zu komprimieren) und Benutzereingaben in sie zu interpolieren.

Nachdem ich ein paar ausprobiert hatte, entschied ich mich für Charcoal, das ich noch nie benutzt hatte (und das wirklich etwas Dokumentation vertragen könnte). Es wurde für ASCII-Kunst entwickelt, kann aber auch Zeichenfolgen in einer Dimension schreiben. ASCII - Zeichen werden in Charcoal buchstäblich gedruckt, was bedeutet, dass für das Drucken von konstanten Zeichenfolgen kein Boilerplate erforderlich istＳ erforderlich Befehl können Sie eine Zeichenfolge interpolieren, die von Benutzereingaben in das Programm übernommen wurde.

Es ist jedoch möglich, etwas kürzer zu werden. Der Perl Universal Quine-Konstruktor enthält zwei ziemlich lange, sich wiederholende Abschnitte. Wir können sie also mit dem ＡBefehl Variablen zuweisen (z. B. Ａ…αder Variablen zuweisen)α ) und die Variablen einfach mit ihren Namen in die Zeichenfolge interpolieren, über die wir drucken. Das spart ein paar Bytes, wenn Sie den String nur buchstäblich schreiben.

Leider fügt Charcoal dem Programm auch eine neue Zeile hinzu, aber das ist keine große Sache. Es kostet lediglich zwei Bytes \n, um diese Zeilenumbruchzeile auch der Eingabe von Q hinzuzufügen.

Beispiel

Wenn wir die Eingabe $_=reverse(die eine Zeichenfolge umkehrt) geben, erhalten wir die folgende Ausgabe:

$_=q($_=reverse"\$_=q($_);eval\n";print);eval

Probieren Sie es online!

Das ist ein Quine-Alike, der seine Quelle wie erwartet rückwärts druckt.

Gelee → Unterlast , 15 Bytes

“(a(:^)*“S):^”j

Probieren Sie es online!

Nimmt die Eingabe-Unterladefunktion Q als befehlsähnliches Argument. Q muss Eingaben vom Stapel nehmen und die Ausgabe an den Stapel senden, ohne zu versuchen, tiefere Stapelelemente zu untersuchen (da sie nicht existieren).

Erläuterung

Die Unterlast

Der hier verwendete universelle Unterlast-Quine-Konstruktor ist:

(a(:^)*…S):^

Der größte Teil des Programms ist ein einzelnes Literal. Wir folgen dem, indem wir :^es kopieren und dann eine Kopie auswerten (wobei die andere Kopie auf dem Stapel verbleibt).

Wenn das Literal mit der Auswertung beginnt, führen wir a(Escape, wodurch es wieder in die gleiche Form wie das ursprüngliche Programm A gebracht wird) und (:^)*(das angehängt wird :^) aus und rekonstruieren so den gesamten Quellcode des Programms. Wir können dann die Funktion Q ausführen, um diese auf beliebige Weise zu transformieren, und das Ergebnis mit ausgeben S.

Das Gelee

Diesmal kann ich Charcoal nicht verwenden, da ein validierender Underload-Interpreter am Ende des Programms abstürzt, wenn das Programm mit einem Zeilenumbruch endet. (Einige Unterlast-Interpreter, wie der von TIO, erzwingen diese Regel nicht, aber ich wollte ordnungsgemäß portierbar sein.) Leider fügt Charcoal seiner Ausgabe natürlich nachgestellte Zeilenumbrüche hinzu. Stattdessen habe ich Jelly verwendet, das in einfachen Fällen wie diesem fast so knapp ist. Das Programm besteht aus einem Listenliteral mit zwei Elementen ( ““”) und fügt sie an der Eingabe ( j) zusammen, wodurch die Benutzereingabe in das Programm interpoliert wird.

Beispiel

Mit der Eingabe :S^(Kopie drucken, Original auswerten) erhalten wir folgendes Unterlastprogramm:

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

Probieren Sie es online!

Dies druckt sich auf interessante Weise unendlich oft von selbst aus: Nach dem normalen Quine-Verhalten wird es evalauf einer Kopie des ausgegebenen Dokuments ausgeführt. Dadurch wird das gesamte rekonstruierte Programm auf unbestimmte Zeit erneut ausgeführt (Unterlast ist schwanzrekursiv). Quinieren Sie sich selbst und machen evalSie eine Endlosschleife in Underload.

RProgN 2 , 11 Bytes

'{`{.%s}{'F

Programmerklärung

'{`{.%s}{'F
'{`{.%s}{'  # Push the string "{`{.%s}{" to the stack.
          F # Format the input with the top of the stack as a template. Which produces {`{.<INPUT>}{

Quine Explination

Das erzeugte Quine ist einfach, verwendet jedoch die Funktionalität von nicht angepassten Funktionshandlern in RProgN2, um ein kurzes und süßes Quine zu erstellen, das als "Looping" -Quine bezeichnet wird. Es ist ein überraschend ähnliches Konzept wie ein <> <Quine.

{`{.}{
{`{.}   # Push the function {`{.} to the stack.
     {  # Try to define a new function, fail, loop back to index 1. (Which in turn, skips the function definition.)
 `{     # Push the string "{" to the stack.
   .    # Concatenate the top two values of the stack, which stringifies the function, then appends { to it.
    }   # Try to terminate a function, fail quietly, and terminate the program.

Natürlich kann aufgrund der Struktur dieses Quines alles andere als echte No-Ops (die nicht verkettet werden) nach der Verkettungsfunktion und gesetzt werden

Einige Quinten

• {`{.i}{: Ausgänge {}i.{`{. iIst nur die "inverse" Funktion, so gibt sich dieses Programm umgekehrt aus.
• {`{.S§.}{: Ausgänge ..S`{{{}§. Swandelt die Zeichenfolge in einen Zeichenstapel um, §sortiert den Stapel lexografisch, fügt ihn dann .wieder zusammen und gibt sich selbst sortiert aus.

Probieren Sie es online!