Su tarea es simple: escriba un programa (o función) que no reciba entradas y produzca (o devuelva) su código fuente. El problema es que cuando el programa está envuelto en "quotes"(carácter Unicode 34), debería generar nuevamente su código fuente (ahora citado).

Se aplican las reglas estándar para quines. Este es el código de golf , por lo que gana el programa más corto (en bytes).

Noodel , 9 7 bytes

Esta versión funciona de la misma manera que la otra, solo que olvidé que Noodel tiene una forma de ejecutar un bloque de código una vez e hice el lenguaje ...

Ḷ1ḥ-Ð1ḥ@€

ḷḥ-Ðḥ@ḅ

Intentalo:)

Cómo funciona

ḷḥ-Ðḥ@ḅ # Single statement that builds itself as a string.
ḷ       # Loop the following block of code unconditionally.
 ḥ-     # Push the string literal of the token preceding this one which pushes "ḷ" onto the stack.
   Ð    # Push the stack as an array to stdout (since is an array it is done by reference).
    ḥ@  # Push the string literal for this block of code which pushes "ḥ-Ðḥ@ḅ" onto the stack.
      ḅ # Break out of the given loop. (The stack is now ["ḷ", "ḥ-Ðḥ@ḅ"]).

        # The top of the stack is popped off and displayed which modifies the array to produce {["ḷ"], "ḥ-Ðḥ@ḅ"} in stdout.

Cotización-Seguridad

Colocar el "personaje antes y después del programa funciona porque Noodel tiene un conjunto de personajes dedicados a lo que yo llamo imprimibles . Estos se analizan inmediatamente como literales de cadena cuando se colocan solos y permiten imprimir fácilmente algo en la pantalla. Entonces, a diferencia de la mayoría de los lenguajes, Noodel ve el conjunto ASCII normal que se considera digno de impresión como literales de cadena directos (excepto el espacio y el avance de línea) en el que citar el código simplemente se ve como presionar cadenas.

"ḷḥ-Ðḥ@ḅ"

"         # Pushes on the string literal "\"" onto the stack.

 ḷḥ-Ðḥ@ḅ  # Same execution as before, simply builds the Quine for this loop.
 ḷ        # Loop the following block of code unconditionally.
  ḥ-      # Push the string literal of the token preceding this one which pushes "ḷ" onto the stack.
    Ð     # Push the stack as an array to stdout (since is an array it is done by reference).
     ḥ@   # Push the string literal for this block of code which pushes "ḥ-Ðḥ@ḅ" onto the stack.
       ḅ  # Break out of the given loop. (The stack is now ["\"", "ḷ", "ḥ-Ðḥ@ḅ"]).

        " # Pushes on the string literal "\"" onto the stack.

          # The top of the stack is popped off and displayed which modifies the array to produce {["\"", "ḷ", "ḥ-Ðḥ@ḅ"], "\""} in stdout.

"Intentalo:)"

Fragmentos

<div id="noodel" code='ḷḥ-Ðḥ@ḅ' input="" cols="10" rows="1"></div>
<script src="https://tkellehe.github.io/noodel/noodel-latest.js"></script>
<script src="https://tkellehe.github.io/noodel/ppcg.min.js"></script>

<div id="noodel" code='"ḷḥ-Ðḥ@ḅ"' input="" cols="10" rows="1"></div>
<script src="https://tkellehe.github.io/noodel/noodel-latest.js"></script>
<script src="https://tkellehe.github.io/noodel/ppcg.min.js"></script>

Python 2 3, 181 152 130 124 122 bytes

""" """>" "or exec("oct=0");p='"""" """>" "or exec("oct=0");p=%r;a=oct==0;print(p[a:~a]%%p)#".';a=oct==0;print(p[a:~a]%p)#

Pruébalo en línea! El TIO viene con un encabezado y un pie de página que prueban automáticamente la validez de la quine. Puede borrarlos para ejecutar la quine.

Este código funciona utilizando las cadenas entre comillas triples en Python. """ """es igual a ' 'y """" """es igual a '" '.

El código usa exec , pero no para la forma "no quiney" de ejecutar datos como código, solo para establecer una variable desde dentro de una expresión. El también execestá codificado correctamente en los datos.

La primera declaración compara la cadena, posiblemente con una cita antepuesta, a " " , y establece la variable en octconsecuencia. (La variable podría haber sido cualquier construcción corta).

El resto del código implementa la quine tradicional de Python usando %r formato de cadena, con algún código adicional que elimina las comillas adicionales si no octse modifica.

Una versión alternativa que usa el "cheaty" execviene en 126 bytes con un código menos repetido:

""" """>" "and exec("oct=0");s='"""" """>" "and exec("oct=0");s=%r;p=%r;exec(p)#".';p='a=oct!=0;print(s[a:~a]%(s,p))';exec(p)#

Pruébalo en línea!

StandardML , 182176108 bytes

";str(chr 34)^it;(print(it^it);fn x=>print(x^it^x^it))";str(chr 34)^it;(print(it^it);fn x=>print(x^it^x^it))

Versión sin comillas: Pruébelo en codingground.
Versión citada: Pruébelo en codingground.

Tenga en cuenta que la salida se parece a esto

> val it = "{some string}" : string
> val it = "{some string}" : string
{output to stdout}> val it = fn : string -> unit

porque el código se interpreta declaración por declaración (cada ;una termina una declaración) y muestra el valor y el tipo de cada declaración.

Antecedentes

En SML hay una quine de la forma <code>"<code in quotes>":

str(chr 34);(fn x=>print(x^it^x^it))"str(chr 34);(fn x=>print(x^it^x^it))" 

y uno en la forma "<code in quotes>"<code>:

";str(chr 34)^it;print(it^it)";str(chr 34)^it;print(it^it)

Ambos se basan en el hecho de que la parte <code>no contiene comillas y, por lo tanto, se puede citar sin la necesidad de escapar de nada, el" necesidad de generar la quine está dada porstr(chr 34) .

También dependen en gran medida del identificador implícito it que se utiliza cuando no se proporciona un identificador explícito en una declaración.

En el primer quine se str(chr 34);une ita la cadena que contiene ", fn x=>comienza una función anónima tomando un argumento x, luego concatena x^it^x^ite imprime la cadena resultante. Esta función anónima se aplica directamente a una cadena que contiene el código del programa, por lo que la concatenación x^it^x^itproduce<code>"<code>" .

La segunda quine comienza solo con el código del programa como cadena ";str(chr 34)^it;print(it^it)";que está vinculada it. Luego str(chr 34)^it;concatena una cita al comienzo de la cadena y, como tampoco se proporciona un identificador explícito, la cadena resultante "<code>está vinculada it. Finalmente print(it^it)concatena la cadena produciendo la misma "<code>"<code>que luego se imprime.

Explicación

Editar: ya no está actualizado con la versión de 108 bytes, sin embargo, uno podría entenderlo también después de leer esta explicación.

La cita segura para presupuestos combina los dos enfoques anteriores y es en sí misma de la forma "<code>"<code>. Poner esto de nuevo entre comillas rinde""<code>"<code>" , por lo que obtenemos una cadena vacía y luego una quine de la otra forma.

Eso significa que el "<code>identificador le da al programa su propia fuente en la forma it, o ites justo "y se nos da nuestra propia fuente <code>como argumento y, por lo tanto, debe ser una función que maneje dicho argumento.

(if size it>1then(print(it^it);fn _=>())else fn x=>print(it^it^x^it^x^it))

Para identificar en qué caso estamos, verificamos si el tamaño de ites mayor que 1. Si no ites así, entonces "estamos y estamos en el segundo caso, por lo que la parte elsedevuelve una función anónima fn x=>print(it^it^x^it^x^it)que luego se llama porque es seguida por la fuente como cadena . Tenga it^it^en cuenta el inicio que se necesita para la cadena vacía al comienzo del programa.

Si size ites mayor que 1, estamos en la parte theny solo actuamos print(it^it), ¿verdad? No del todo, porque olvidé decirte que SML está fuertemente tipado, lo que significa que un condicional if <cond> then <exp_1> else <exp_2>siempre debe tener el mismo tipo, lo que nuevamente significa que las expresiones <exp_1>y <exp_2>deben tener el mismo tipo. Ya sabemos el tipo de la elseparte: una función anónima que toma una cadena y luego llama printtiene tipo string -> <return type of print>y printtiene tipo string -> unit( unites de alguna manera similar a voiden otros idiomas), por lo que el tipo resultante es nuevamentestring -> unit .

Entonces, si la thenparte fuera solo la print(it^it)que tiene tipo unit, obtendríamos un error de desajuste de tipo. ¿Y qué tal fn _=>print(it^it)? ( _es un comodín para un argumento que no se usa) Esta función anónima por sí sola tiene un tipo 'a -> unitdonde 'arepresenta un tipo arbitrario, por lo tanto, en el contexto de nuestro condicional que impone un string -> unittipo, esto funcionaría. (La variable type 'ase instancia con type string.) Sin embargo, en este caso no imprimiríamos nada ya que nunca se llama a la función anónima. Recuerde, cuando vamos en la parte- thenel código general es "<code>"<code>, entonces la parte se <code>evalúa como una función pero, como nada viene después, no se llama.

En su lugar se utiliza un sequentialisation que tiene la forma (<exp_1>; ...; <exp_n>)en <exp_1>que <exp_n-1>pueden tener tipos arbitrarios y el tipo de <exp_n>proporciona el tipo de todo el sequentialisation. Desde un punto de vista funcional, los valores de <exp_1>to <exp_n-1>simplemente se descartan, sin embargo, SML también admite construcciones imperativas, por lo que las expresiones pueden tener efectos secundarios. En resumen, tomamos (print(it^it);print)como parte then, imprimiendo primero y luego devolviendo la función printque tiene el tipo correcto.

V , 27 , 23 bytes

éPñi"éP241"qpá"lxx|xÿ

Pruébalo en línea!

Como contiene algunos caracteres no imprimibles, aquí hay una versión legible:

éPñi"éP<C-v>241<esc>"qpá"lxx|xÿ

y aquí hay un hexdump:

00000000: e950 f169 22e9 5016 3234 311b 2271 70e1  .P.i".P.241."qp.
00000010: 226c 7878 7c78 ff                        "lxx|x.

Entonces, lo primero que debemos hacer es determinar si el primer carácter es una cita. éPinserta un carácter 'P', pero "éPes un NOOP. Después de eso, ejecutamos una ligera modificación en la quine extensible estándar, que es:

ñi<C-v>241<esc>"qpÿ

Sin embargo, lo haremos de manera ligeramente diferente. En primer lugar, debemos insertar el texto inicial "éP". Entonces hacemos

ñ                        " Start recording into register 'q'
 i                       " Enter insert mode
  "éP<C-v>241<esc>       " Enter the following text: '"éPñ'
                  "qp    " Paste the text in register 'q'
                     á"  " Append a '"'

Aquí es donde ocurre la ramificación. El texto actualmente en el búfer es

"éPñi"éP<C-v>241<esc>"qpá"P
Cursor is here ----------^

A menos que lo envuelvamos entre comillas, en ese caso, la 'P' nunca se habría insertado, y el búfer es:

"éPñi"éP<C-v>241<esc>"qpá"
Cursor is here ----------^

Como todavía estamos grabando, podemos hacer lo que queramos aquí, y se agregará al búfer cuando "qpsuceda. Entonces, desde aquí, es bastante fácil eliminar condicionalmente las comillas:

l           " Move one character to the right. If there is no character to the right, 
            " then this is effectively a "break" statement, stopping playback of the recording
 xx         " Delete two characters (the '"P')
   |        " Move to the first character on this line
    x       " Delete one character
     ÿ      " End the program

JavaScript (ES6), 239 237 bytes

Set=``;eval(";a='Set=``;eval(~;a=1;S=String.fromCharCode;q=S(34);r=Set&&q;s=S(39);alert(r+a.replace(/[^ -}]/g,q).replace(1,s+a+s)+r);~)';S=String.fromCharCode;q=S(34);r=Set&&q;s=S(39);alert(r+a.replace(/[^ -}]/g,q).replace(1,s+a+s)+r);")

Procure probar cada versión en un entorno nuevo (por ejemplo, una nueva pestaña del navegador)

Tiene que haber al menos una forma de simplificar esto ...