Tâche

Vous recevrez une chaîne dans l'entrée composée uniquement des caractères de aà z, c'est- à -dire que l'entrée correspondra à l'expression régulière /^[a-z]*$/.

Votre sortie doit être un programme complet dans la même langue, dont le code source contient l'entrée et est un quine approprié.

Exemple

Votre programme recevrait les entrées abcet les sorties:

...abc...

Ce qui précède devrait être un programme complet dans la même langue qui ne prend aucune entrée et sortie:

...abc...

c'est à dire qu'il sort lui-même.

Notation

C'est du code-golf . La réponse la plus courte en octets l'emporte.

Les références

• Qu'est-ce qui constitue une quine appropriée?

Python 3, 57 61 octets

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

Prend une quine python 3 de base d' ici et remplace le nom de la variable par l'entrée.

Remarque: Comme l' a souligné Hyper Neutrino dans les commentaires, cela ne fonctionne pas pour les mots - clés réservés comme for, if, etc.

L'ajout d'un caractère auquel aucun des mots clés réservés ne se termine par tel que 'x'ou n'importe quel nombre corrige cela. (Ørjan Johansen).

Gelée , 9 octets

Générateur

;“¶Øv”ṾØv

Essayez-le en ligne!

Comment ça fonctionne

;“¶Ø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

Si l'entrée est quine, le programme suivant est généré.

“quine
Øv”Ṙv

Essayez-le en ligne!

Comment ça fonctionne

Ceci est la quine Jelly standard. Premier,

“quine
Øv”

définit l'argument gauche et la valeur de retour sur la chaîne "quine\nØv".

Imprime ensuite Ṙune représentation sous forme de chaîne (le code du bloc précédent) et renvoie la chaîne non modifiée.

Ensuite, vprend l'argument de gauche et le passe comme entrée au programme Jelly

quine
Øv

Dans tous les programmes Jelly, seul le lien principal (défini sur la dernière ligne) est exécuté, donc la première ligne est entièrement ignorée.

Enfin, Øvdéfinit la valeur de retour sur "Ṙv", qui est imprimée implicitement lorsque le programme externe se termine.

Haskell , 51 octets

q prend une chaîne et renvoie une chaîne.

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

Essayez-le en ligne!

Exemple de sortie pour putStr$q"test":

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

Essayez-le en ligne!

• Place le texte de quine principal et la chaîne souhaitée dans un tuple.
• Utilise fstpour extraire le texte principal.
• Utilise showpour transformer le tuple entier en chaîne.
• Permet mappendde combiner les deux fonctions précédentes. Idéalement mappendsur deux fonctions donne une fonction qui applique chaque fonction à son argument et combine les résultats avec mappendpour le type de résultat (ici la concaténation de chaînes).

Sous-charge , 14 octets

(~aSaS(:^)S):^

Essayez-le en ligne!

Utilisez comme (test)(~aSaS(:^)S):^- qui est en soi une quine.

Comment ça fonctionne

• La sous-charge est un langage ésotérique concaténatif (basé sur la pile). Il ne prend pas en charge la lecture des entrées, donc tous les arguments sont initialement placés sur la pile.
• (test)et (~aSaS(:^)S)sont des littéraux de chaîne, alors placez-vous sur la pile, cette dernière en haut.
• :duplique la (~aSaS(:^)S)chaîne au-dessus de la pile, puis ^exécute son contenu en tant que sous-programme.
• ~échange les deux premiers éléments de la pile, c'est donc maintenant le (test)plus haut.
• a enveloppements (test) entre parenthèses supplémentaires.
• Sprend la chaîne ((test))au-dessus de la pile et l'imprime sans les parenthèses externes (qui ne sont que la syntaxe littérale).
• Maintenant aSImprime le reste (~aSaS(:^)S)de la pile de manière similaire (avec les parenthèses).
• Enfin, (:^)Simprime la finale :^.

Sous-charge , 14 octets

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

Essayez-le en ligne!

Une approche différente de l'autre réponse Underload; plutôt que d'être lui-même un quine, cela construit un quine. Fait intéressant, cela revient au même nombre d'octets. Il s'agit d'une fonction qui prend son argument de la pile et sort en sortie standard.

Explication

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

La fonction résultante ressemble à ceci:

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

En d'autres termes, il imprime un littéral de chaîne se contenant, suivi de :^. Il s'agit clairement d'une quine (car ce qui vient d'être imprimé est le même que le code que nous avons exécuté pour l'exécuter en premier lieu).

V , 9 octets

ñ"qPxÉÑ~j

Essayez-le en ligne!

Il s'agit d'une modification du quine V standard , et je suis fier que ce ne soit qu'un octet de plus.

Hexdump:

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

Explication:

ñ           " 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

Ensuite, l'enregistrement s'arrête implicitement et est lu. Cela générera la sortie suivante:

ñ"qPxÉÑ~jHello

Puisque la jlecture de la macro sera interrompue, rien ne Hellosera jamais exécuté.

Python 2, 38 octets

Bien que l'entrée ne soit nécessaire que pour la prise en charge a-z, cela devrait fonctionner avec toute entrée sur une seule ligne qui ne contient pas d'octets NUL.

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

Essayez-le en ligne

Pour l'entrée, abcle quine résultant est:

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

Essayez-le en ligne

RProgN 2 , 15 octets

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

Expliqué

Utilisation du format

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

où %qest l'entrée qouted, construit une quine de la saveur

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

qui est un quine RProgN2 standard, {']C'.}]Cqui, avant la fin, ajoute et détruit la chaîne entrée.

Essayez-le en ligne!

Rétine , 14 octets

Le nombre d'octets suppose un codage ISO 8859-1.

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

Essayez-le en ligne!

Pour l'entrée x, cela génère:

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

Explication

La sortie est une modification mineure du quine standard . Nous utilisons simplement l'expression régulière |xau lieu de l'expression régulière vide. Étant donné que le |permet toujours (et priorise) et la correspondance vide, la fonctionnalité elle-même n'est pas affectée, et puisqu'elle xne contiendra que des lettres, il est garanti que la syntaxe regex est elle-même valide.

L'impression utilise en fait une technique similaire à la quine elle-même. Pour éviter la duplication de la quine, nous n'insérons ¶\(*S1`|qu'une seule fois au début de la chaîne. C'est exactement la moitié du code source. Pour l'imprimer deux fois sans saut de ligne, nous utilisons la configuration \(\, qui enveloppe tout le programme dans un groupe et fait que la scène elle-même ainsi que le groupe le contenant impriment le résultat sans saut de ligne.

Japt , 14 octets

"\"iQ ²ª`"+U ²

Testez-le en ligne! Pour une entrée de abc, sorties

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

qui sort lui-même. Testez-le en ligne!

Explication

Il s'agit d'une extension de la norme Japt compatible avec la charge utile:

"iQ ²"iQ ²

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

La seule différence est que nous ajoutons ª`abcà la fin, ce qui est fondamentalement en JavaScript ||"abc". Puisque le résultat de la première partie est toujours une chaîne non vide (véridique), le ||ne s'exécute jamais.

Il existe plusieurs versions alternatives de la même longueur:

"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 14 octets

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

Essayez-le en ligne!

Comment ça fonctionne

"`_~"           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)

Qui sort quelque chose comme "`_~\"test\";"`_~"test";.

JavaScript, 21 octets

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

Perl 5 , 35 octets

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

Essayez-le en ligne!