Aufgabe

Sie erhalten eine Zeichenfolge in der Eingabe, die nur aus den Zeichen von abis besteht z, dh die Eingabe entspricht dem regulären Ausdruck /^[a-z]*$/.

Ihre Ausgabe sollte ein vollständiges Programm in der gleichen Sprache sein, dessen Quellcode die Eingabe enthält und eine korrekte Quine ist.

Beispiel

Ihr Programm würde die Ein- abcund Ausgabe erhalten:

...abc...

Das obige sollte ein komplettes Programm in derselben Sprache sein, das keine Ein- und Ausgaben benötigt:

...abc...

dh es gibt sich selbst aus.

Wertung

Das ist Code-Golf . Kürzeste Antwort in Bytes gewinnt.

Verweise

• Was zählt als richtige Quine?

Python 3, 57 61 Bytes

lambda x:"s='s=%r;print(s%%s)';print(s%s)".replace('s',x+'x')

Nimmt eine grundlegende Python 3 quine von hier und ersetzt die Variablennamen mit dem Eingang.

Anmerkung: Wie bereits in den Kommentaren von Hyper Neutrino aus, dies nicht funktioniert für reservierte Schlüsselwörter wie for, ifusw.

Das Anhängen eines Zeichens, mit dem keines der reservierten Schlüsselwörter endet, 'x'oder einer Zahl, behebt dies. (Ørjan Johansen).

Gelee , 9 Bytes

Generator

;“¶Øv”ṾØv

Probieren Sie es online!

Wie es funktioniert

;“¶Øv”ṾØv  Main link. Argument: s (string of letters)

;“¶Øv”     Concatenate s and the string "\nØv".
      Ṿ    Uneval; get its string representation.
           (implicit) Print the previous return value since the next link is an
           otherwise unparsable nilad.
       Øv  Set the return value to "Ṙv".

Quine

Bei Eingabe von wird quinedas folgende Programm generiert.

“quine
Øv”Ṙv

Probieren Sie es online!

Wie es funktioniert

Dies ist die Standard-Gelee-Quine. Zuerst,

“quine
Øv”

Setzt das linke Argument und den Rückgabewert auf den String "quine\nØv".

Dann Ṙdruckt eine String - Darstellung (der Code aus dem vorherigen Block) und gibt den unveränderten String.

Nimmt danach vdas linke Argument und übergibt es als Eingabe an das Jelly-Programm

quine
Øv

In allen Jelly-Programmen wird nur der Hauptlink (der in der letzten Zeile definiert ist) ausgeführt, sodass die erste Zeile vollständig ignoriert wird.

Legt schließlich Øvden Rückgabewert auf fest "Ṙv", der implizit gedruckt wird, wenn das äußere Programm beendet ist.

Haskell , 51 Bytes

q Nimmt eine Zeichenfolge und gibt eine Zeichenfolge zurück.

q s|t<-"main=putStr$fst`mappend`show$"=t++show(t,s)

Probieren Sie es online!

Beispielausgabe für putStr$q"test":

main=putStr$fst`mappend`show$("main=putStr$fst`mappend`show$","test")

Probieren Sie es online!

• Fügt den Quine-Haupttext und die gewünschte Zeichenfolge in ein Tupel ein.
• Dient fstzum Extrahieren des Haupttexts.
• Verwendet show, um das gesamte Tupel in eine Zeichenfolge zu verwandeln.
• Verwendet mappend, um die beiden vorherigen Funktionen zu kombinieren. Zweckmäßigerweise gibt es mappendfür zwei Funktionen eine Funktion, die jede Funktion auf ihr Argument anwendet und die Ergebnisse mit mappenddem Ergebnistyp kombiniert (hier Zeichenfolgenverkettung).

Unterlast , 14 Bytes

(~aSaS(:^)S):^

Probieren Sie es online!

Verwenden Sie als (test)(~aSaS(:^)S):^- das ist selbst ein Quine.

Wie es funktioniert

• Unterlast ist eine verkettete (stapelbasierte) esoterische Sprache. Das Lesen von Eingaben wird nicht unterstützt, daher werden zunächst alle Argumente auf den Stapel gelegt.
• (test)und (~aSaS(:^)S)sind Zeichenkettenliterale, also legen Sie sich auf den Stapel, wobei letzterer oben liegt.
• : dupliziert die (~aSaS(:^)S) Zeichenfolge über dem Stapel und ^führt den Inhalt als Unterprogramm aus.
• ~ tauscht also jetzt die beiden obersten Elemente auf dem Stapel aus (test) .
• a Wraps (test) in zusätzliche Klammern eingeschlossen.
• S Nimmt die Zeichenfolge ((test)) über den Stapel und druckt sie ohne die äußeren Klammern (die nur wörtliche Syntax sind).
• Jetzt aS der Rest (~aSaS(:^)S)des Stapels in ähnlicher Weise gedruckt (mit den Klammern).
• Endlich wird (:^)Sdas Finale gedruckt :^.

Unterlast , 14 Bytes

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

Probieren Sie es online!

Ein anderer Ansatz als die andere Unterlastantwort; Dies ist kein Quine, sondern ein Quine. Interessanterweise kommt es auf die gleiche Anzahl von Bytes. Dies ist eine Funktion, die ihr Argument vom Stapel auf die Standardausgabe überträgt.

Erläuterung

a(aS(:^)S)~*:^
a               Generate a string literal containing the input
 (aS(:^)S)~*    Prepend "aS(:^)S"
            :^  Mockingbird: run the resulting function with itself as argument

Die resultierende Funktion sieht folgendermaßen aus:

aS(:^)S(input)
aS              Print a string literal containing the argument
  (:^)S         Print ":^"
       (input)  Push "input" onto the stack

Mit anderen Worten, es wird ein String-Literal ausgegeben, das sich selbst enthält, gefolgt von :^. Dies ist eindeutig eine Quine (weil das, was gerade gedruckt wurde, derselbe Code ist, den wir ausgeführt haben, um es überhaupt auszuführen).

V , 9 Bytes

ñ"qPxÉÑ~j

Probieren Sie es online!

Dies ist eine Modifikation des Standard-V-Quines , und ich bin stolz darauf, dass dies nur ein Byte länger ist.

Hexdump:

00000000: f122 7150 78c9 d17e 6a                   ."qPx..~j

Erläuterung:

ñ           " Record the following commands into register 'q'
 "qP        " Paste register 'q' before all input
    x       " Delete the last character of what we just pasted (this will be a 'ÿ')
     ÉÑ     " Insert 'Ñ' at the beginning of this line
       ~    " Toggle the case of this character
        j   " Move down a line. During playback, this will cancel playback of the current macro,
            " So everything after here is a NOOP

Dann stoppt die Aufnahme implizit und wird wiedergegeben. Dies erzeugt die folgende Ausgabe:

ñ"qPxÉÑ~jHello

Da jdie Wiedergabe des Makros unterbrochen wird, Hellowird niemals etwas ausgeführt.

Python 2, 38 Bytes

Obwohl die Eingabe nur zur Unterstützung erforderlich ist a-z, sollte dies mit jeder einzeiligen Eingabe funktionieren, die keine NUL-Bytes enthält.

s='s=%r;print s%%s#'+input();print s%s

Probieren Sie es online aus

Für die Eingabe abcergibt sich als Quine:

s='s=%r;print s%%s#abc';print s%s#abc

Probieren Sie es online aus

RProgN 2 , 15 Bytes

"{']C'.%q[}]C"F

Erklärt

Verwendung des Formats

{']C'.%q[}]C}

Wo %qist die Qouted-Eingabe, bildet eine Quine des Geschmacks

{']C'."Some Text"[}]C

Dies ist eine Standard-RProgN2-Quine, {']C'.}]Cdie vor Beendigung die eingegebene Zeichenfolge anfügt und zerstört.

Probieren Sie es online!

Retina , 14 Bytes

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

\(\`^
¶\(*S1`|

Probieren Sie es online!

Für die Eingabe xgibt diese Folgendes aus:

\(*S1`|x
\(*S1`|x

Erläuterung

Die Ausgabe ist eine geringfügige Modifikation des Standard-Quines . Wir verwenden einfach den regulären Ausdruck |xanstelle des leeren regulären Ausdrucks. Da das |noch zulässt (und priorisiert) und leere Übereinstimmung, ist die Funktionalität selbst nicht betroffen, und dax immer nur Buchstaben enthalten werden, ist die gültige Regex-Syntax selbst garantiert.

Beim Drucken wird eine Technik verwendet, die der des Quines selbst ähnelt. Um das Duplizieren des Quines zu vermeiden, fügen wir ¶\(*S1`|nur einmal am Anfang der Zeichenkette ein. Das ist genau die Hälfte des Quellcodes. Um es zweimal ohne Zeilenvorschub zu drucken, verwenden wir die Konfiguration \(\, die das gesamte Programm in eine Gruppe einwickelt und bewirkt, dass sowohl die Bühne selbst als auch die Gruppe, die es enthält, das Ergebnis ohne Zeilenvorschub druckt.

Japt , 14 Bytes

"\"iQ ²ª`"+U ²

Testen Sie es online! Für eine Eingabe von abc, Outputs

"iQ ²ª`abc"iQ ²ª`abc

was sich ausgibt. Testen Sie es online!

Erläuterung

Dies ist eine Erweiterung des Standard-Japt-Quine mit Nutzlast:

"iQ ²"iQ ²

"iQ ²"      // Take this string.  iQ ²
      iQ    // Insert a quote.    "iQ ²
         ²  // Repeat this twice. "iQ ²"iQ ²
            // Implicit: output result of last expression

Der einzige Unterschied besteht darin, dass wir ª`abcam Ende anfügen , was in JavaScript im Grunde genommen der Fall ist ||"abc". Da das Ergebnis des ersten Teils immer eine nicht leere Zeichenfolge ist (truey), wird die ||nie ausgeführt.

Es gibt mehrere alternative Versionen derselben Länge:

"iQ ²ª`abc"iQ ²ª`abc   quine||"abc"
"iQ ²ª$abc"iQ ²ª$abc   quine||abc
"iQ ²ª{abc"iQ ²ª{abc   quine||function(){ ... }
"iQ ²ªXabc"iQ ²ªXabc   quine||X.a(...) (X could be any uppercase letter or digit)
"iQ ²//abc"iQ ²//abc   quine//abc      (// is a comment in JS/Japt)
"iQ ²;[abc"iQ ²;[abc   quine;          (unmatched [ causes a parsing error)

CJam , 16 bis 14 Bytes

"`_~"q`';++`_~

Probieren Sie es online!

Wie es funktioniert

"`_~"           e# Push "`_~"
     q`         e# Push a string representation of the input (input wrapped in quotes)
       ';       e# Push a semicolon
         ++     e# Concatenate all this together
           `    e# Get the string representation of the resulting string
            _~  e# Duplicate it and eval it (pushing the original string on the stack again)

Welches gibt sowas aus "`_~\"test\";"`_~"test";.

JavaScript, 21 Bytes

$=_=>`$=${$}/*${_}*/`

Perl 5 , 35 Bytes

$_=q{say"\$_=q{$_};eval"#}.<>;eval

Probieren Sie es online!