Por lo general, los políglotas se construyen de tal manera que cada idioma puede ignorar partes del código que están presentes para otros idiomas, envolviéndolos en literales de cadena, utilizando sintaxis de comentarios u otros trucos similares.

Su objetivo es escribir un políglota donde el resultado para cada idioma es el código del políglota que produce ese resultado. Específicamente, la salida debe construirse a partir del código políglota con solo eliminaciones, y debe ser una quine en el idioma dado.

Reglas

• Solo se permiten las quines adecuadas (no leer el código fuente, no tomar entradas, la salida debe ser a STDOUT o la alternativa más cercana si STDOUT no es una opción, y los programas deben consistir en más que solo literales que se imprimen implícitamente).
• Dado que diferentes idiomas pueden usar diferentes codificaciones, los bytes sin procesar son lo que importa aquí. Por ejemplo, si el idioma A usa UTF-8 y el idioma B usa CP437, el código (hexadecimal) C3 88 46 47sería ÈFGpara el idioma A y ÈFGpara el idioma B.
• Todas las salidas deben ser distintas (de nuevo, comparar bytes sin procesar). Esto evita complicaciones al tratar de restringir versiones de idiomas menores: si dos idiomas usan la misma parte del código para hacer lo mismo, no puede reclamarlos a ambos.
  • Si tiene dos idiomas A y B, que XYson una salida válida en ambos, pero YZtambién es válida en B, puede elegir XYcomo salida para A y YZcomo salida para B, por lo que puede reclamar ambos en su puntaje ( pero no puede reclamar XYambos idiomas debido a la regla anterior).
• Todas las salidas deben ser lo más cortas posible. Por ejemplo, si su código era print('foo')#something, para Python 3 (ignorando el hecho de que la salida no es correcta), el código que necesitaría generar sería print('foo'), y print('foo')#no estaría permitido. Si hay varias cadenas de igual (mínima) longitud que producen la salida correcta, puede elegir cualquiera de ellas.
• Los envíos deben ser políglotas en al menos 2 idiomas.
• Tu puntuación será dada por (number of programming languages with distinct outputs)**3/(total byte size of polyglot). El puntaje más alto gana. En el caso de que dos presentaciones alcancen el mismo puntaje, la presentación que alcanzó ese puntaje primero ganará.

GolfScript + CJam + Fission 2 + Jelly , 4 idiomas, 24 bytes, puntuación 2.667

Comencemos con el volcado hexadecimal:

00000000:  3322 3024 700a 2721 2b4f 5222 0a3c 3024 700a 6523 7fff cccc

Para GolfScript, CJam y Fission 2, interpretamos esto en una codificación de un solo byte compatible con ASCII como ISO 8859-1 (la codificación exacta realmente no importa, porque los lenguajes solo definen operadores para caracteres ASCII de todos modos):

3"0$p
'!+OR"
<0$p
e#<DEL>ÿÌÌ

¿Dónde <DEL>está el personaje de control 0x7f?

En Jelly, se supone que está en la página de códigos de Jelly, donde se ve así en su lugar:

3"0$p½'!+OR"½<0$p½e#¶”ṘṘ

GolfScript

El een la última línea es una variable desconocida y #comenta el resto de la línea, por lo que esto imprime

"0$p"
0$p

con un avance de línea final. Esta es la versión políglota GolfScript / CJam de la quine estándar:

".p"
.p

Prueba el políglota. El | Prueba la quine.

CJam

Aquí, e#comenta la última línea, de manera casi idéntica, esto imprime

"0$p"
0$p

sin un avance de línea final.

Prueba el políglota | Prueba la quine.

Fisión

La fisión solo ve la segunda línea, que es la quine de fisión estándar, por lo que imprime

'!+OR"

No puedo proporcionar un enlace en línea para el políglota aquí, porque TIO envía el archivo a Fission como UTF-8, pero Fission lee la fuente byte por byte, lo que hace que la última línea sea demasiado larga. Sin embargo, he probado esto localmente con un archivo codificado ISO 8859-1 (en el que la última línea tiene la misma longitud que la segunda), para confirmar que esto funciona.

Prueba la quine.

Jalea

El pilcrow es un alias para avances de línea en Jelly, por lo que la fuente es equivalente a:

3"0$p½'!+OR"½<0$p½e#
”ṘṘ

Todos menos la última línea de un programa Jelly son "enlaces de ayuda" (es decir, funciones) que pueden ignorarse a menos que se llamen, siempre que sean sintácticamente válidos. Esta es realmente la razón por la que 3viene primero en los programas CJam y GolfScript, porque de lo contrario "no se puede analizar en Jelly.

De lo contrario, dado que no se llama a la función, el programa es equivalente a solo su segunda línea, que es la quine Jelly estándar.

Prueba el políglota. El | Prueba la quine.

> <> + Python, 2 idiomas, 51 46 bytes, puntaje ~ = 0.16 0.17

Como todavía no hay respuestas, comenzaré con una simple.

#.09;!?lo}*2+2f"
_='_=%r;print _%%_';print _%_

Pruébelo para > <> y Python

Para> <> la primera línea es una quine (# refleja, "pone toda la línea en la pila, luego presionamos 34 (charcode para") e imprimimos todo), la ejecución nunca se mueve de ella, por lo que efectivamente ignora el resto de el código.

Para Python, la primera línea es un comentario, mientras que la segunda es un quine (enfoque estándar en python, que utiliza la sustitución de cadenas con la misma cadena que ambos argumentos).

JavaScript + Python 2 + Japt, 3 idiomas, 132 bytes, puntaje ~ = 0.205

A="`i96d)p2`i96d)p2";1//2;A=1
S="S=%s;console.log(S,uneval(S))";A//2;S="S=%r;print S%%S";"""
console.log(S,uneval(S))//""";print S%S

Esto imprime

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

en JavaScript (solo en Firefox),

S='S=%r;print S%%S';print S%S

en Python 2, y

`i96d)p2`i96d)p2

en Japt (¡ Pruébelo en línea! )

JavaScript

Esto es lo que JavaScript ve:

A="`i96d)p2`i96d)p2";1
S="S=%s;console.log(S,uneval(S))";A
console.log(S,uneval(S))

La primera línea es no operativa porque Ano se usa de ninguna manera. La segunda línea se establece Sen la cadena S=%s;console.log(S,uneval(S))y la tercera la imprime después de reemplazarla %scon la unevalrepresentación ed de S(solo Sentre comillas). El resultado es una quine en JavaScript.

Pitón

Esto es básicamente lo que ve Python:

A="`i96d)p2`i96d)p2";1//2;A=1
S="S=%s;console.log(S,uneval(S))";A//2;S="S=%r;print S%%S"
print S%S

La primera línea es prácticamente no operativa; La única parte importante es A=1al final. Esto se convierte Aen un número para que la división de enteros A//2en la segunda línea no arroje un error.

La segunda línea es principalmente de la misma manera, excepto que se establece Sen la cadena S=%r;print S%%S. La tercera línea se imprime Sdespués de reemplazar la %rcon la representación en bruto de S(simplemente Senvuelta entre comillas simples). El resultado es una quine en Python 2.

Japt

Este es el código JavaScript que ve el intérprete de Japt:

A="`i96d)p2`i96d)p2";1//2;A=1
S="S=%s;console.log(S,uneval(S))";A//2;S="S=%r;print S%%S";"","\nconsole.log(S,uneval(S))//","";.p("r".i("n".t(),S%S))

Como puede ver, es casi lo mismo que la respuesta de JavaScript, con una excepción principal: las dos últimas líneas se combinan. Como resultado, esto es lo que el intérprete ve realmente:

A="`i96d)p2`i96d)p2";1
S="S=%s;console.log(S,uneval(S))";A

La primera línea se establece Aen la línea Japt y la segunda línea Sen parte de la línea JS. Sin embargo, en Japt, solo se envía a la salida la última expresión; esto es A, entonces la salida es `i96d)p2`i96d)p2.

Jolf +> <>, puntaje = 2 ** 3/15 = 0.533 ....

"r0:g>o<
"Q«Q«

Trabajando para agregar otro idioma a esto.

> <>, Python 2 y 3, 3 idiomas, 107 bytes, puntaje = 27/107 ~ = 0.252

#o<}-1:"
a=1/1is 1;b="(_%(_,b))"[a:-a|9];_='a=1/1is 1;b="(_%%(_,b))"[a:-a|9];_=%r;print %s';print (_%(_,b))

Pruébalo en línea: Python 2 , Python 3 , > <>

La salida de Python 3 es exactamente la segunda línea, y la salida de Python 2 es esta quine . La salida> <> es la primera línea.

Explicación

Este programa se basa en la clásica quine de Python 2:

_='_=%r;print _%%_';print _%_

Primero, para que sea compatible con Python 2 y Python 3, cambié el print declaración a una llamada de función y agregué un espacio adicional que será útil más adelante:

_='_=%r;print (_%%_)';print (_%_)

Luego, necesitaba una forma de distinguir Python 2 de Python 3. Una de las formas más simples es aprovechar el hecho de que /es la división entera en Python 2, pero la división flotante en Python 3. Por lo tanto, el siguiente código se evalúa Trueen Python 2, peroFalse en Python 3:

1/1is 1

Para hacer que las salidas sean distintas entre los dos idiomas, necesitaba eliminar selectivamente el primer y último paréntesis en la printllamada (es por eso que necesitaba el espacio antes, sin espacio, no sería una printdeclaración válida en Python 2) . Por lo tanto, necesitaba modificar el arnés de quine así:

a=1/1is 1;b="(_%(_,b))"[a:-a|9];_='a=1/1is 1;b="(_%%(_,b))"[a:-a|9];_=%r;print %s';print (_%(_,b))

Esa expresión se a:-a|9evalúa como 0:9en Python 2 y 1:-1en Python 3. Por lo tanto, bestá "(_%(_,b))"en Python 3, pero en Python 2 se descartan el primer y el último carácter, dejando _%(_,b). Y con esa modificación, el políglota fue válido para este desafío.

Como sugiere Teal pelican, la quine> <> #o<}-1:"podría agregarse con bastante facilidad, gracias al hecho de que #comienza un comentario de una sola línea en Python. Simplemente preponiéndola y una nueva línea agrega otro idioma y aumenta la puntuación casi diez veces.

Python 2 + Retina, 2 idiomas, 55 bytes, puntaje = 2 ^ 3/55 ≈ 0.145

Solía ​​en $nlugar de ¶mantener los dos ASCII válidos.

S='S=%r;print S%%S';print S%S#|
#$n\(*S1`$n\(*S1`
#\`#

Pitón , Retina

Pitón:

S='S=%r;print S%%S';print S%S

Retina:

\(*S1`
\(*S1`

> <> + Pyke + Python 2, 81 bytes, puntaje = 3 ** 3/81 ~ 0.333

"""r00gol?!;60.
a=%r;print a%%a"""#);"34.Cp\D\Es"DEp00/
a=__doc__[-15:]
print a%a

Intenté hacer algo diferente con todos los idiomas.

> <> ve:

"""r00gol?!;60.

Esta es una ligera modificación del estándar> <> quine para usar una cadena con comillas triples al principio. Esto permite que las comillas triples finales para Python estén en una línea diferente.

Pruébalo en línea!

Pyke ve:

"34.Cp\D\Es"DEp00/

No había creado una quine en Pyke antes y, por lo tanto, tuve que pensar en una. Utilicé técnicas tradicionales de combinación para crear una cadena y luego evaluarla consigo misma como entrada. Tenga en cuenta que para que esto funcione sin impacto visual, las advertencias deberán desactivarse. Errores con un error de división por 0 en el paso de generación.

Pruébalo aquí! O solo la parte quine.

Python ve:

Todo. Python usa todo el código para producir su quine. Decidí incrustar la parte quine en la cadena de documentación (aunque en última instancia ahorraría bytes para eliminar, pero creo que es genial). Es una modificación de la técnica de quining estándar.

Pruébalo en línea!