En mi tiempo en PPCG, he notado que los problemas de quine y los problemas de políglotas son bastante populares. Además, las meta-soluciones a los problemas, es decir, los scripts que generan un programa que es la solución a un problema, tienden a recibir muchos comentarios positivos de la comunidad. Por lo tanto, he creado este desafío, que implementa estas tres ideas.

Entonces, su tarea, lector y entusiasta del golf de código , es crear lo más breve posible un script que pueda ejecutarse en dos idiomas A y B para generar quines para A y B. Cuando su programa se ejecuta en el idioma A, debe generar un programa que es un quine en lenguaje B pero no en lenguaje A y viceversa. Los idiomas A y B pueden ser versiones diferentes del mismo idioma, siempre que tenga en cuenta que las quines generadas solo deberían funcionar en una de las versiones.

Tenga en cuenta que las lagunas estándar deben considerarse cerradas y solo se permiten las cotas adecuadas .

¡Buena suerte, gana la menor cantidad de personajes!

CJam 0.6.6 dev / GolfScript, 15 14 12 bytes

"0$p"0$~a:n;

¡Gracias a @ jimmy23013 por jugar golf en 2 bytes!

Descanse para ser actualizado.

Verificación

Dado que el envío implica un espacio en blanco significativo, es mejor comparar los hexdumps.

$ xxd -g 1 mpquine
0000000: 22 60 30 24 7e 22 30 24 7e 4e 4d 3a 6e 3b        "`0$~"0$~NM:n;
$
$ cjam mpquine | tee quine.gs | xxd -g 1
0000000: 22 60 30 24 7e 22 60 30 24 7e 0a                 "`0$~"`0$~.
$ golfscript quine.gs | xxd -g 1
0000000: 22 60 30 24 7e 22 60 30 24 7e 0a                 "`0$~"`0$~.
$ cjam quine.gs | xxd -g 1
0000000: 22 60 30 24 7e 22 60 30 24 7e                    "`0$~"`0$~
$
$ golfscript mpquine | tee quine.cjam | xxd -g 1
0000000: 22 60 30 24 7e 22 60 30 24 7e                    "`0$~"`0$~
$ cjam quine.cjam | xxd -g 1
0000000: 22 60 30 24 7e 22 60 30 24 7e                    "`0$~"`0$~
$ golfscript quine.cjam | xxd -g 1
0000000: 22 60 30 24 7e 22 60 30 24 7e 0a                 "`0$~"`0$~.

CJam

Impresiones de CJam "`0$~"0$~y un avance de línea final. Pruébalo en línea!

El programa generado imprime "`0$~"0$~con el avance de línea final en GolfScript (¡ Pruébelo en línea! ), Pero sin el avance de línea en CJam (¡ Pruébelo en línea! ).

Como funciona la metaquina

"`0$~"         e# Push that string on the stack.
      0$~      e# Push a copy and evaluate it:
               e#   `     Inspect the string, pushing "\"`0$~\"".
               e#    0$   Push a copy.
               e#      ~  Evaluate, pushing "`0$~".
               e# Both "\"`0$~\"" and "`0$~" are now on the stack.
         NM    e# Push "\n" and "".
           :n; e# Map print over the elements of "" (none) and pop the result.
               e# "\"`0$~\"", "`0$~", and "\n" are now on the stack, and the
               e# characters they represent will be printed implicitly.

Como funciona la quine

"`0$~"          # Push that string on the stack.
      0$~       # As in CJam.
         <LF>   # Does nothing.
                # "\"`0$~\"" and "`0$~" are now on the stack, and the characters
                # they represent will be printed implicitly, plus a linefeed.

A diferencia de GolfScript, CJam no imprime un salto de línea final de forma predeterminada, por lo que no es una quine en CJam.

GolfScript

Impresiones GolfScript "`0$~"0$~, sin espacios en blanco al final. Pruébalo en línea!

El programa generado imprime "`0$~"0$~sin espacios en blanco al final en CJam (¡ Pruébelo en línea! ), Pero GolfScript agrega un salto de línea (¡ Pruébelo en línea! ).

Como funciona la metaquina

"`0$~"0$~       # As in CJam.
         NM     # Unrecognized token. Does nothing.
           :n   # Store the top of the stack – "`0$~" – in the variable n. n holds
                # "\n" by default. When the program finishes, the interpreter
                # prints n implicitly, usually resulting in a trailing linefeed.
                # By redefining n, it will print "0$~" instead.
             ;  # Pop the string from the stack so it won't be printed twice.

Como funciona la quine

"`0$~"0$~      e# Works as in GolfScript.

A diferencia de CJam, GolfScript agregará un salto de línea al contenido de la pila, por lo que no es una quine en GolfScript.

CJam / Fission, 22 bytes

"'!+OR'")5-"{'_'~}_~";

Pruébalo en CJam. Pruébalo en fisión.

En CJam, esto imprime la quine de fisión estándar :

'!+OR"

Prueba la quisión de fisión.

En Fission, esto imprime una "variante sin la versión estándar de CJam quine:

{'_'~}_~

Prueba la quine CJam.

Esto también funciona para 22 bytes (imprimiendo los mismos quines):

"& *NQ!":)R"{'_'~}_~";

Explicación

En CJam:

"'!+OR'"    e# Push this string.
)           e# Pull off the last character.
5-          e# Subtract 5, turning ' into ".
"{'_'~}_~"  e# Push this string.
;           e# And discard it again.

Entonces, al final del programa, la pila contiene la cadena "'!+OR"y el carácter ", los cuales se imprimen implícitamente.

En Fission, el flujo del programa comienza en el Rcon un átomo a la derecha. '"solo cambia la masa de los átomos ), 5y -son ignorados por varias razones. Luego, el átomo ingresa al modo de impresión en "y se imprime {'_'~}_~. ;destruye el átomo y termina el programa.

Clojure / Common Lisp, 274 bytes

(defmacro t []"((fn [s] (print (list s (list (quote quote) s)))) (quote (fn [s] (print (list s (list (quote quote) s))))))")(if '()(print(let[s clojure.string/replace](.toUpperCase(s(s(s(s(s(t)"fn""lambda")"[s]""(s)")"(quote ""'")"e)""e")")))))""))))"))))(eval '(princ(t))))

Algunos espacios agregados para facilitar la lectura

(defmacro t []"((fn [s] (print (list s (list (quote quote) s))))
     (quote (fn [s] (print (list s (list (quote quote) s))))))")
(if '()(print(let[s clojure.string/replace](.toUpperCase
    (s(s(s(s(s(t)"fn""lambda")"[s]""(s)")"(quote ""'")"e)""e")")))))""))))"))))
    (eval '(princ(t))))

Básicamente define una macro que devuelve una quine en Clojure. Clojure requiere parámetros para la definición de macro proporcionados como vector ( []) mientras que Common Lisp (afortunadamente) simplemente lo ignora. Después de eso, diferimos 2 idiomas evaluando '()cuál es igual nily, por lo tanto, falsey en Common Lisp y está trueen Clojure. Luego hacemos manipulaciones de cadenas usando Clojure que Common Lisp ni siquiera intenta evaluar a medida que avanza en otra iframa. Clojure, por otro lado, intenta verificar si otra rama es al menos correcta antes de ejecutarla, por lo que tuvo que usarla evalpara ser correcta en Clojure y generar la cadena correcta en Common Lisp.

Nota: solo devolver dos cadenas diferentes probablemente sea más corto, pero no será diferente a los desafíos de un políglota sobre la salida de cadenas diferentes en diferentes idiomas. ¯ \ _ (ツ) _ / ¯

Ejecución original de Clojure: https://ideone.com/SiQhPf

Fuente original común de Lisp ejecutada: https://ideone.com/huLcty

Salida Clojure: ((LAMBDA (S) (PRINT (LIST S (LIST 'QUOTE S)))) '(LAMBDA (S) (PRINT (LIST S (LIST 'QUOTE S)))))

Salida común de Lisp: ((fn [s] (print (list s (list (quote quote) s)))) (quote (fn [s] (print (list s (list (quote quote) s))))))

Salida de Clojure ejecutada en Common Lisp: https://ideone.com/T1DF7H

Viceversa: https://ideone.com/Fezayq

Jelly / GolfScript, 18 16 bytes

0000000: 3a 6e 22 ff cc cc 22 7d 7f fe 22 3a 6e 60 ff 3b  :n"..."}..":n`.;

Verificación

La prueba de todos los programas involucrados con los flujos de bytes exactos solo se puede hacer localmente.

$ LANG=en_US # Latin-1. Jelly doesn't care about the exact encoding,
$            # as longs as it's not UTF-8.
$
$ xxd -g 1 mpquine
0000000: 3a 6e 22 ff cc cc 22 7d 7f fe 22 3a 6e 60 ff 3b  :n"..."}..":n`.;
$
$ jelly f mpquine | tee quine.gs | xxd -g 1
0000000: 22 3a 6e 60 22 3a 6e 60                          ":n`":n`
$ golfscript quine.gs | xxd -g 1
0000000: 22 3a 6e 60 22 3a 6e 60                          ":n`":n`
$ jelly f quine.gs 2> /dev/null | xxd -g 1
$
$ golfscript mpquine | tee quine.jelly | xxd -g 1
0000000: ff cc cc                                         ...
$ jelly f quine.jelly | xxd -g 1
0000000: ff cc cc                                         ...
$ golfscript quine.jelly | xxd -g 1
0000000: 0a

Jalea

Con la página de códigos de Jelly , el programa tiene el siguiente aspecto.

:n"”ṘṘ"}
“":n`”;

Esto imprime (¡ Pruébelo en línea! )

":n`":n`

que es una quine en GolfScript (¡ Pruébelo en línea! ), pero un error del analizador en Jelly (¡ Pruébelo en línea! ).

GolfScript

En Latin-1, el programa tiene el siguiente aspecto, con un carácter DEL no imprimible entre }y þ.

:n"ÿÌÌ"} þ":n`ÿ;

Esto imprime (¡ Pruébelo en línea! )

ÿÌÌ

o, visualizado con la página de códigos de Jelly,

”ṘṘ

que es una quine en Jelly (¡ Pruébelo en línea! ), pero solo imprime un salto de línea en GolfScript (¡ Pruébelo en línea! ).

JavaScript / C 278 bytes

Con la asombrosa cifra de 278 bytes:

//\
console.log('int main(){char*A="int main(){char*A=%c%s%c;printf(A,34,A,34);}";printf(A,34,A,34);}');/*
int main(){puts("A='A=;B=String.fromCharCode(39);console.log(A.slice(0,2)+B+A+B+A.slice(2));';B=String.fromCharCode(39);console.log(A.slice(0,2)+B+A+B+A.slice(2));");}//*/

La quina C:

int main(){char*A="int main(){char*A=%c%s%c;printf(A,34,A,34);}";printf(A,34,A,34);}

La quine de JavaScript:

A='A=;B=String.fromCharCode(39);console.log(A.slice(0,2)+B+A+B+A.slice(2));';B=String.fromCharCode(39);console.log(A.slice(0,2)+B+A+B+A.slice(2));

Befunge / Fisión, 35 bytes

"$TQ-#'">,#-:#2_@;"+1_@#`+66:,g0:"L

Pruébalo en Befunge | Pruébalo en fisión

En Befunge esto produce la quina de fisión :

'!+OR"

En Fission esto produce la quine Befunge :

:0g,:66+`#@_1+

Python / Retina, 70 65 64 66 bytes

Usé la misma estrategia que usé en mi anterior políglota Python / Retina .

#
print"\nS`((.+))"*2+"\n\n"
#?
#_='_=%r;%_\n';_
#?;
#;print _%
#

Probar en Python | Prueba en retina

#es un comentario en Python, por lo que simplemente imprime la quina Retina en Python. En Retina, la primera etapa (2 líneas) no hace nada, porque no #se encontrará ninguna en la entrada. La siguiente etapa no reemplaza nada con la base de la quine de Python. La tercera etapa reemplaza cada punto y coma con la #print _%pieza. La última etapa elimina todo #.

Quine en Retina:

S`((.+))
S`((.+))

Quine en Python:

_='_=%r;print _%%_\n';print _%_

Las quines utilizadas pueden verse en este desafío . La quina de Retina es un error en Python, y la quina de Python no tiene salida en Retina.

Python 3 / Python 2, 62 bytes

_='_=%r;print(_%%_['+'~'*-~int(-1/2)+'int(-1/2):])';print(_%_)

Pruébalo en Python 2 , Python 3 .

Basado en la quine de Python aquí . El factor distintivo entre las dos versiones es con lo que hacen int(-1/2): en Python 2, /es la división entera (redondeando hacia abajo), con el resultado de -1; en Python 3, /es la división de coma flotante ( -0.5), que se inttrunca a 0.

Construimos una cadena _en tres partes. '_=%r;print(_%%_['y 'int(-1/2):])'siempre son lo mismo. La parte interesante es '~'*-~int(-1/2):

• En Python 2, -~int(-1/2)es 0, y la tilde no se agrega a la cadena;
• En Python 3, -~int(-1/2)es 1, y la tilde se agrega a la cadena.

Por lo tanto, Python 2 genera la quine de Python 3

_='_=%r;print(_%%_[int(-1/2):])';print(_%_[int(-1/2):])

y Python 3 genera la quine de Python 2

_='_=%r;print(_%%_[~int(-1/2):])';print(_%_[~int(-1/2):])

En cada versión, la expresión dentro se [ :]evalúa como 0, lo que hace que el segmento incluya toda la cadena, mientras que en el lenguaje incorrecto se evalúa -1, lo que hace que el segmento incluya solo el último carácter, truncando la salida para que no sea una quine completa.

Brain-Flak , brainfuck 4617 4009 bytes

((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((()()()())))()())[()()])))()()())[()()])))())[()])[()()()()])))))))))))))))))))))))))))))))))))))))))))()()())()())[()()()()])()()())[()()])()())[()()()()])()()()))()()())[()()])[()()()()])))))))))))))))))))()())))()()())[()()()()])()()()()())[()()]))()())[()()()])()())[()()])))()()())[()()])))())[()()])[()()()])))))))))))))))))))))))))))))))))))))))))))()()()())[()()()])()()()())[()()])[()()()]))()()()())[()()()])()()()())[()()])[()()()])()()()())[()()()])()()()())[()()])[()()()]))))))))))))))()()()())[()()()])()()()())[()()])[()()()]))()()()())[()()()])()()()())[()()])[()()()])))))))))))))))))))))))))))))()()()())[()()()])()()()())[()()])[()()()]))()()()())[()()()])()()()()()))))))[()()()])[()])()()))))()()){({}<>)<>}<>([]){({}[()]<(({}[()]<((((((()()()){}())){}{}){}())<>)>)<>){({}[()]<({}()())>){({}[()]<({}())>){({}[()]<({}((()()()){}()){})>){({}[()]<({}()())>){({}[()]<({}(((()()()){}()){}){}())>){(<{}({}()())>)}}}}}}{}([]<({}<{({}<>)<>}<>>)>){({}[()]<({}<>)<>>)}{}{({}[()]<(({}))>)}{}(((({})(((()()())){}{}){}())))<>>)}{}{<>({}<>)}{+++++++>>>+>>>+++++++>>>++++++++>>>+++>>>++++>>>++>>>+++>>>++++>>>++++++++>>>+++>>>++++>>>+>>>+++++>>>++++++>>>++>>>+++++++>>>+>>>+++++++>>>++++++++>>>+++++>>>+>>>++>>>++++++>>>+++>>>+>>>+>>>+++++++>>>++++++++>>>+++++>>>+>>>++>>>++++++>>>+++>>>+>>>+>>>+>>>+>>>+>>>+>>>+>>>+>>>+>>>++>>>+>>>++>>>+>>>++>>>+>>>++>>>+>>>++>>>++>>>+++++++>>>++++++++>>>++>>>+++++++>>>++++++++>>>++>>>+++++++>>>++++++++>>>++>>>+++>>>++++>>>++>>>++>>>+>>>++>>>++>>>++>>>++++>>>++>>>+++>>>++++>>>++>>>+++++++>>>+>>>+++++++>>>++++++++>>>+++++>>>+>>>++>>>++++++>>>+++>>>+>>>+++++++>>>++++++++>>>+>>>++>>>++>>>++++>>>++>>>+++++++>>>+>>>+++++++>>>++++++++>>>+++++>>>+>>>++>>>++++++>>>+++>>>+>>>+++++++>>>++++++++>>>+>>>+>>>+>>>+>>>++>>>+>>>++>>>+>>>++>>>++>>>++>>>+++++++>>>++++++++>>>+++++++>>>++++++++>>>++>>>+++++++>>>++++++++>>>+>>>++>>>++>>>++++>>>++>>>+++++++>>>+>>>+++++++>>>++++++++>>>+++++>>>+>>>++>>>++++++>>>+++>>>+>>>+++++++>>>++++++++>>>+>>>++>>>+>>>++>>>++>>>++++>>>++>>>+++++++>>>+>>>+++++++>>>++++++++>>>+++++>>>+>>>++>>>++++++>>>+++>>>+>>>+++++++>>>++++++++>>>+>>>+>>>+>>>+>>>++>>>+>>>++>>>+>>>++>>>++>>>+++++++>>>++++++++>>>+>>>++>>>++>>>+++++++>>>++++++++>>>++>>>+++++++>>>++++++++>>>+>>>++>>>++>>>++++>>>++>>>+++++++>>>+>>>+++++++>>>++++++++>>>+++++>>>+>>>++>>>++++++>>>+++>>>+>>>+++++++>>>++++++++>>>+>>>++>>>+>>>++>>>++>>>++++>>>++>>>+++++++>>>+>>>+++++++>>>++++++++>>>+++++>>>+>>>++>>>++++++>>>+++>>>+>>>+++++++>>>++++++++>>>+>>>+>>>+>>>+>>>++>>>+>>>++>>>+>>>++>>>+>>>++>>>+>>>++>>>++>>>++>>>+++++++>>>++++++++>>>+++++++>>>++++++++>>>++>>>+++++++>>>++++++++>>>++>>>++++>>>++>>>+++++++>>>+>>>+++>>>+++++++>>>++++++++>>>+>>>+++++++>>>++++++++>>>+>>>++>>>+>>>++>>>++>>>++++>>>++>>>++++++++>>>++++++++>>>++++++++>>>++++++++>>>++++++++>>>++++++++>>>++++++++>>>+++++++>>>++++++++>>>+>>>+++++>>>++++++>>>+++>>>+>>>+++++++>>>++++++++>>>+++>>>+++++++>>>+>>>+++++++>>>++++++++>>>+++>>>++++>>>++>>>+++>>>++++>>>++++++++>>>+++>>>++++>>>++++>>>++>>>++++>>>++>>>+++++++>>>+>>>+++++++>>>++++++++>>>+++++>>>+>>>++>>>++++++>>>+++>>>+>>>+++++++>>>++++++++>>>+++>>>++++>>>++>>>+++>>>++++>>>++++>>>++>>>++++++++>>>+++++++>>>++++++++>>>+++++++>>>+>>>+++++++>>>++++++++>>>+++++>>>+>>>++>>>++++++>>>+++>>>+>>>+>>>+>>>+++++++>>>++++++++>>>+++++>>>+>>>++>>>++++++>>>++>>>+>>>++>>>++>>>++>>>++++>>>++>>>++++++++>>>+++++++>>>++++++++>>>+++>>>++++>>>++++>>>++>>>++++++++>>>+++++++>>>++++++++>>>+++>>>++++>>>+++++++>>>+>>>+++++++>>>++++++++>>>+++>>>++++>>>++>>>+++>>>++++>>>++++++++>>>+++>>>++++>>><<<[<<<]>>>[>++++++++++++++++++++++++++++++++++++++++.<[->.+.->+<<]>+.[-]>>]<[<<<]>>>[<++++++++++++++++++++++++++++++++++++++++>-[<+>-[<+++++++++++++++++++>-[<++>-[<+++++++++++++++++++++++++++++>-[<++>-[<++++++++++++++++++++++++++++++>-[<++>-]]]]]]]<.>>>>]}{}

Pruébalo en línea!

Pruébalo en línea!

La explicación está en camino. Todavía estoy jugando golf.