Tarea

Se le dará una cadena en la entrada que consta solo de los caracteres de aa z, es decir, la entrada coincidirá con la expresión regular /^[a-z]*$/.

Su salida debe ser un programa completo en el mismo idioma, cuyo código fuente contiene la entrada, y es una quine adecuada.

Ejemplo

Su programa recibiría la entrada abcy salida:

...abc...

Lo anterior debe ser un programa completo en el mismo lenguaje que no requiere entradas y salidas:

...abc...

es decir, sale por sí mismo.

Puntuación

Este es el código de golf . La respuesta más corta en bytes gana.

Referencias

• ¿Qué cuenta como una quine adecuada?

Python 3, 57 61 bytes

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

Toma una quine básica de Python 3 de aquí y reemplaza el nombre de la variable con la entrada.

Nota: Como se ha señalado por Hyper Neutrino en los comentarios, esto no funciona para palabras clave reservadas como for, if, etc.

Al agregar un carácter con el que ninguna de las palabras clave reservadas termina, como 'x'o cualquier número, lo arregla. (Ørjan Johansen).

Jalea , 9 bytes

Generador

;“¶Øv”ṾØv

Pruébalo en línea!

Cómo funciona

;“¶Ø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 la entrada es quine, se genera el siguiente programa.

“quine
Øv”Ṙv

Pruébalo en línea!

Cómo funciona

Esta es la quine Jelly estándar. Primero,

“quine
Øv”

establece el argumento izquierdo y el valor de retorno en la cadena "quine\nØv" .

Luego, Ṙ imprime una representación de cadena (el código del bloque anterior) y devuelve la cadena inalterada.

Luego, vtoma el argumento izquierdo y lo pasa como entrada al programa Jelly

quine
Øv

En todos los programas de Jelly, solo el enlace principal se ejecuta (definido en la última línea), por lo que la primera línea se ignora por completo.

Finalmente, Øvestablece el valor de retorno en "Ṙv", que se imprime implícitamente cuando finaliza el programa externo.

Haskell , 51 bytes

q toma una cadena y devuelve una cadena.

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

Pruébalo en línea!

Ejemplo de salida para putStr$q"test":

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

Pruébalo en línea!

• Pone el texto de quine principal y la cadena deseada en una tupla.
• Utiliza fstpara extraer el texto principal.
• Utiliza showpara convertir toda la tupla en una cadena.
• Utiliza mappendpara combinar las dos funciones anteriores. Convenientemente mappenden dos funciones da una función que aplica cada función a su argumento y combina los resultados con mappendel tipo de resultado (aquí concatenación de cadenas).

Baja carga , 14 bytes

(~aSaS(:^)S):^

Pruébalo en línea!

Úselo como (test)(~aSaS(:^)S):^, que es en sí mismo una quine.

Cómo funciona

• Underload es un lenguaje esotérico concatenativo (basado en pila). No admite entradas de lectura, por lo que cualquier argumento se coloca inicialmente en la pila.
• (test)y (~aSaS(:^)S)son literales de cadena, por lo que se colocan en la pila, con el último en la parte superior.
• :duplica la (~aSaS(:^)S)cadena en la parte superior de la pila, luego ^ejecuta su contenido como un subprograma.
• ~intercambia los dos elementos superiores de la pila, por lo que ahora (test)está en la parte superior.
• aEnvolturas (test)entre paréntesis adicionales.
• S toma la cuerda ((test)) en la parte superior de la pila e imprime sin los paréntesis externos (que son solo sintaxis literal).
• Ahora aSimprime el resto(~aSaS(:^)S) en la pila de manera similar (con paréntesis).
• Por fin, (:^)Simprime la final :^.

Baja carga , 14 bytes

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

Pruébalo en línea!

Un enfoque diferente de la otra respuesta de baja carga; en lugar de ser una quine, esto construye una quine. Curiosamente, sale a la misma cantidad de bytes. Esta es una función que toma su argumento de la pila y las salidas a la salida estándar.

Explicación

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 función resultante se ve así:

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

En otras palabras, imprime un literal de cadena que se contiene a sí mismo, seguido de :^. Esto es claramente una quine (porque lo que se acaba de imprimir es el mismo que el código que ejecutamos para ejecutarlo en primer lugar).

V , 9 bytes

ñ"qPxÉÑ~j

Pruébalo en línea!

Esta es una modificación de la quine V estándar. , y estoy orgulloso de que solo sea un byte más.

Hexdump:

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

Explicación:

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

Luego, la grabación se detiene implícitamente y se reproduce. Esto generará el siguiente resultado:

ñ"qPxÉÑ~jHello

Como jinterrumpirá la reproducción de la macro, Hellonunca se ejecutará nada .

Python 2, 38 bytes

Aunque la entrada solo es necesaria para admitir a-z, esto debería funcionar con cualquier entrada de línea única que no contenga bytes NUL.

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

Pruébalo en línea

Para la entrada, abcla quine resultante es:

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

Pruébalo en línea

RProgN 2 , 15 bytes

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

Explicado

Usando el formato

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

¿Dónde %qestá la entrada de Qouted, construye una quine del sabor

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

que es una quine RProgN2 estándar, {']C'.}]Cque, antes de terminar, agrega y destruye la cadena ingresada.

Pruébalo en línea!

Retina , 14 bytes

El recuento de bytes asume la codificación ISO 8859-1.

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

Pruébalo en línea!

Para la entrada x, esto produce:

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

Explicación

La salida es una modificación menor de la quine estándar . Simplemente usamos la expresión regular en |xlugar de la expresión regular vacía. Como |todavía permite (y prioriza) y la coincidencia vacía, la funcionalidad en sí no se ve afectada, y dado quex que solo contendrá letras, se garantiza que la sintaxis de expresión regular sea válida.

Imprimir esto en realidad usa una técnica que es similar a la quine misma. Para evitar la duplicación de la quine, insertamos ¶\(*S1`|solo una vez en el comienzo de la cadena. Eso es exactamente la mitad del código fuente. Para imprimirlo dos veces sin un salto de línea, utilizamos la configuración \(\, que envuelve todo el programa en un grupo y hace que tanto la etapa misma como el grupo que lo contiene impriman el resultado sin un salto de línea.

Japt , 14 bytes

"\"iQ ²ª`"+U ²

¡Pruébalo en línea! Para una entrada de abc, salidas

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

que sale por sí mismo. ¡Pruébalo en línea!

Explicación

Esta es una extensión de la línea estándar de capacidad de carga de Japt:

"iQ ²"iQ ²

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

La única diferencia es que agregamos ª`abcal final, que en JavaScript es básicamente ||"abc". Como el resultado de la primera parte es siempre una cadena no vacía (verdad), ||nunca se ejecuta.

Hay varias versiones alternativas de la misma longitud:

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

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

Pruébalo en línea!

Cómo funciona

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

Lo que produce algo así "`_~\"test\";"`_~"test";.

JavaScript, 21 bytes

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

Perl 5 , 35 bytes

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

Pruébalo en línea!