Una metaquina es un programa que no es una quina, pero cuya salida, cuando se ejecuta como un programa en el mismo lenguaje, es una quine.

El objetivo de este desafío es escribir una metaquina. Este es el código de golf , por lo que el código más corto gana, con la respuesta más antigua utilizada como un desempate. Tenga en cuenta que solo los programas completos son aceptables, debido a la definición de quine.

Reglas para Quines

Solo se aceptan quines verdaderos . Es decir, debe imprimir el código fuente completo textualmente a STDOUT, sin :

• leyendo su código fuente, directa o indirectamente.
• confiando en un entorno REPL que simplemente evalúa e imprime cada expresión que le da de comer.
• confiando en las características del lenguaje que solo imprimen la fuente en ciertos casos.
• usando mensajes de error o STDERR para escribir todo o parte de la línea. (Puede escribir cosas a STDERR o generar advertencias / errores no fatales siempre que STDOUT sea una quine válida y los mensajes de error no formen parte de ella).
• el código fuente que consiste únicamente en literales (ya sean literales de cadena, literales numéricos, etc.) y / o NOP.

Cualquier salida no suprimible (como avisos de derechos de autor, mensajes de inicio / apagado o un avance de línea final) puede ignorarse en la salida en aras de la validez de la quine.

Ejemplo

Ignorando la regla que prohíbe los programas literales y las comillas incorporadas, esto sería una metaquina en serio:

"Q"

El programa consta del literal de cadena única "Q", que se imprime implícitamente en la salida. Cuando Qse ejecuta la salida ( ), es una quine ( Qes la función de quine incorporada).

CJam, 6 bytes

"_p"_p

Huellas dactilares

"_p"
_p

que es la quine más corta adecuada en CJam.

Pruébalo aquí.

Explicación

Ambos programas funcionan exactamente igual, ya que el salto de línea dentro de la línea adecuada no funciona y solo se incluye porque es más costoso eliminarlo de la salida. Cómo funcionan los programas:

"_p"  e# Push this string.
_     e# Duplicate it.
p     e# Print a string representation of the top of the stack (i.e. the string with
      e# quotes) followed by a linefeed.
      e# The other copy is then printed automatically at the end of the program, without
      e# stringifying it.

Nota al margen

Lo mismo funciona en GolfScript que

".p".p

que imprime

".p"
.p

con un avance de línea final, que a su vez es una de las quines más cortas conocidas.

Pyth, 12 11 10 9 bytes

Eliminó un byte más gracias a @ Pietu1998.

jN B".[9N

Esto imprime

.[9N".[9N

que es una quine en Pyth. Puedes probarlo aquí .

Fisión , 6 bytes.

!+OR"'

Huellas dactilares

'!+OR"

Cuál es la quine de fisión más corta . Esto funciona porque los cambios cíclicos del programa dejan su producción completamente inalterada.

Pruébalo en línea!

Javascript ES6, 21 bytes

$=_=>`$=${$};$()`
$()

Trivial.

Python 2, 29 bytes

_="_=%r;print _%%_";print _%_

Resulta que la conocida quine de pitón corta se convierte fácilmente en una metaquina :)

Y, dado que no tenemos que preocuparnos por hacer coincidir la nueva línea final, ¡la metaquina es en realidad más corta!

Japt, 15 13 bytes

Q+"+Q ³s7J" ²

¡Pruébalo en línea!

Este programa genera

"+Q ³s7J"+Q ³s7J

que es la quine más corta conocida en Japt.

Cómo funciona

Q+"..." // Take a quotation mark plus this string.  "+Q ³s7J
²       // Repeat it twice.                         "+Q ³s7J"+Q ³s7J
        // Implicit output

Versión no competitiva, 11 bytes

Q+"+Q ²é" ²

He acaba de agregar é , un comando de "rotar". Entonces

"+Q ²é"+Q ²é

ahora es una quine válida.

Rubí, 25 23

puts"puts <<2*2,2
"*2,2

Genera el clásico ruby ​​HEREdoc quine

puts <<2*2,2
puts <<2*2,2
2

Vieja solución

_='_=%p;$><<_%%_';$><<_%_

Se genera solo con las comillas simples reemplazadas por comillas dobles.

JavaScript, 50 bytes

a="a=%s;console.log(a,uneval(a))";eval(a.slice(5))

Basado en el quine más corto de JS sin lectura de fuente conocido por el hombre , pero unos 8 bytes más cortos. Huellas dactilares

a="a=%s;console.log(a,uneval(a))";console.log(a,uneval(a))

que es una quine

Pez (> <>), 17 bytes

Esto funciona utilizando la clásica quine de pescado, "r00g!;oooooooo|pero agrega una {que desplaza toda la pila a la izquierda para que el programa original no sea una quine, pero su salida, cuando se ejecuta, lo es.

"{r00g!;oooooooo|

Salidas:

"r00g!;oooooooo|

que es una quine de pescado!

Gelatina , 3 bytes (no competitiva)

Desafortunadamente, los átomos requeridos son aproximadamente 2 semanas más jóvenes que el desafío.

Metaquina

”Ṙv

Pruébalo en línea!

Cómo funciona

”Ṙv  Main link. No arguments.

”Ṙ   Set the left argument and the return value to the character 'Ṙ'.
  v  Dyadic eval; evaluate the return value with the left argument as argument.
     Executing the atom Ṙ on the argument 'Ṙ' prints a string representation of
     the character, i.e., the string "”Ṙ".
     Finally, v returns its unaltered argument, which is printed implicitly.

Quine

”ṘṘ

Pruébalo en línea!

Cómo funciona

”ṘṘ  Main link. No arguments.

”Ṙ   Set the left argument and the return value to the character 'Ṙ'.
  Ṙ  Print a string representation of the character, i.e., the string "”Ṙ".
     (implicit) Print the unaltered return value.

Como el segundo Ṙimprime los dos primeros caracteres ( ”Ṙ), esta es una quine adecuada según nuestra definición.

Octopen-Baru, 22 bytes

** Respuesta no competitiva

愛[35211].pack歩U')

Salida de rubí

puts [35211].pack(' U')

Que salidas 見. ¡Qué quine en Octopen-Baru!

7 , 2 bytes, desafío de fechas posteriores al idioma

El programa tiene dos bytes de longitud y puede interpretarse de varias maneras; como un volcado hexadecimal:

00000000: 4ff4                                     O.

como la página de códigos 437:

O⌠

o, lo más legible, en octal (que 7 usa de forma nativa):

237723

Pruébalo en línea!

El funcionamiento de esto es muy simple: es la quine estándar 7 con un elemento de pila no operativo insertado entre las dos mitades, para que sea diferente (en este contexto, 7separa los elementos de la pila). (También podría haberlo insertado al principio 723723. No podría haberlo interpretado al final porque los 7 finales son como espacios en blanco finales e ignorados en la codificación empaquetada, por lo que no sería diferente del programa de salida. )

Por cierto, este programa es un palíndromo en hexadecimal, pero eso es principalmente una coincidencia.

Baja carga, 11 bytes

(:aSS)::aSS

Bastante simple. Se imprime (:aSS):aSS, que es la quine de subcarga estándar.

Brachylog , 12 bytes

"~k;?w₁"gjw₃

Pruébalo en línea!

Una de 132 variaciones metaquine misma longitud en la quine traduje de Brachylog v1 de Fatalize quine (no trampa). De hecho, escribí un programa (no golfista y en general tonto) para imprimirlos todos:

{[[";?","gj","jḍ"],"₁₃₅₇"]j∋ᵐ{ḍ≠&};"\"~~k~ww~w\"~ww~w~n"}ᶠ{lw" metaquines generated:
"ẉ&}w₁ᵐ

Pruébalo en línea!

Hay dos partes de la quine original que podría ser sustituido sin consecuencias: ;?se puede cambiar a gjo jḍ, y ₁se puede cambiar a ₃, ₅o ₇. Si los guardamos o cambiamos fuera del literal de cadena de una manera y dentro del literal de cadena de una manera diferente, entonces la salida no coincidirá con la fuente, porque las variantes que estén presentes dentro del literal de cadena se imprimirán tanto dentro como fuera de él. , lo que resulta en una quine que no era la ejecución inicial del programa.

;?, gjy jḍson intercambiables porque los tres emparejan el literal de la cadena consigo mismo: debido al diseño del programa, la variable de entrada ?se unifica con la cadena, por lo que ;?empareja la cadena consigo misma; independientemente del diseño, gjenvuelve la cadena en una lista que luego se concatena a sí misma; asimismo jḍconcatena la cadena a sí misma y luego la divide por la mitad.

Los wsubíndices impares son intercambiables porque, aunque originalmente wsolo podía tomar 0 o 1, con 0 imprimiendo la entrada wy 1 imprimiendo el primer elemento formateado con el segundo, el inventario de subíndices para no está restringido o establecido en la entrada, y el valor alto El bit codifica si la impresión se realiza de inmediato o si se retrasa hasta el final del programa, por lo que puede estar sujeto a retroceso. (Esos subíndices fueron mi primera y hasta ahora la mayor contribución a Brachylog). Dado que la quine y la metaquina no usan la variable de salida y no retroceden, los cuatro subíndices impares son equivalentes.w ha convertido en algo que funciona externamente como un campo de bits: el bit bajo del subíndice codifica si es directo o formateado, el bit medio codifica si la variable de salida dew

Befunge-93, 22 bytes

"+1_@#`+39:,g0:">:#,_@

Simplemente tomé la quine estándar, la puse entre comillas, la invertí (para que se cargue correctamente en la pila) y luego agregué una impresión de pila al final.

Son 8 caracteres agregados a la quine normal, por lo que es muy posible que haya una mejor solución.

Turtlèd , 52 bytes (sin competencia)

1 menos que la quine original

@##'@r,r,r-{ +.r_}r{ +.r_}"#'@r,r,r-{ +.r_}r{ +.r_}"

Funciona de la misma manera, excepto que no tiene un carácter al final, cuando se ejecuta, tendrá un carácter al final, que no afecta a la salida, porque escribe # en un #. Tenga en cuenta que la salida es ligeramente diferente a la quine que hice para el desafío de quine, pero funciona de la misma manera: "escribe #, que es su último carácter, como la quine que hice. Consulte la explicación allí .

Lua, 45 bytes

El código Quine no es mío.

s="s=%qprint(s:format(s))"print(s:format(s));

resultará en

s="s=%qprint(s:format(s))"print(s:format(s))

que es una quine Me alegro de que ;es opcional en Lua.

Pushy , 7 bytes

No competir ya que el lenguaje es posterior al desafío.

Esta es la quine estándar, pero con las nuevas líneas eliminadas. Las nuevas líneas no significan nada en Pushy, pero son el separador estándar del operador de impresión y, por lo tanto, son necesarias para una verdadera quine.

95 34_"

Pruébalo en línea! Esto produce:

95 34
_ "

Cuál es la quine más breve de Pushy: puede encontrar una explicación sobre cómo funciona aquí .

Alternativamente, H5-34_"funciona para el mismo número de bytes.

Espuma , 14 bytes.

[. .'|: ~|]: ~

Esto imprime la segunda quine de espuma que se puede encontrar aquí . En realidad, esto es más corto porque .siempre colocará un espacio entre cada elemento, pero la barra en el tercer token me permite omitir el espacio anterior.

Casco , 6 bytes

D"S+s¨

Pruébalo en línea!

Imprime el estándar Husk quine S+s"S+s".

 "S+s¨    The string S+s"
D         concatenated with itself.

La quine explicó:

   "S+s"    The string S+s
 +          concatenated with
S           itself passed through
  s         the function which returns its string representation.