Quine de pedidos

10

Escriba un programa que, cuando se ejecuta en diferentes idiomas, genera una permutación de bytes diferente del código en cada idioma. El código fuente exacto se cuenta como una permutación.

Aquí "lenguaje diferente" puede ser una versión diferente (Py 2 y Py 3) o diferentes banderas estándar. Es una salida diferente que obliga a una versión diferente.

Se aplican reglas de quine adecuadas para el programa en cada idioma. Su puntaje se calcula como (Language count)^6/(Code length in bytes), con un puntaje más alto es mejor.

Muestra:

Si el código es AABen funcionamiento en tres idiomas diferentes rendimientos ABA, AABy AAB, a continuación, su puntuación es 2^6/3(sólo uno de los dos AABrecuento). Está bien si no ABAtiene sentido.

code-challenge quine polyglot l4m2
fuente
1
¿Qué cuenta como un idioma diferente?
Laikoni
44
¿Qué definición de quine adecuada se aplica? (¿ Martin's , o ais523's , o tal vez alguna otra definición en estos meta hilos?) ¿Se aplican las reglas de quine adecuadas solo a las interpretaciones del programa que en realidad son quines? (Por lo que vale, no creo que este desafío mejore mucho al hacer cumplir las reglas de quine adecuadas).
Lynn el
Para aclarar, trabajando en su ejemplo: si mi código se AABimprime AABen el idioma 1 y ABAen el idioma 2, supongo que debe ser una quine adecuada cuando se ve como un programa de idioma 1, y no hay más restricciones que impliquen su interpretación como un programa de lenguaje 2. ¿Está bien?
Lynn
1
¿La longitud del código se cuenta en caracteres o bytes? ¿Qué debemos hacer con diferentes codificaciones de caracteres?
dylnan
1
¿Qué pasa con los bytes frente a los caracteres?
dylnan

Respuestas:

10

Befunge-98 , > <> , Gol> <> , fisión , Wumpus , Cardinal , cera de abejas y Alice Puntuación: 8 6 /88 = 2978.909

"65*4+059*$!#.39*0jp2+'Wk,@ ''5&.'\d&o@o&88#+\@ol?!,'.'0.6'!+Ox,++tttt=++%-$#}.6~.F4*`*R

Pruébalo en Befunge! Pruébalo en> <>! Pruébalo en Gol> <>! Pruébalo en fisión! ¡Pruébalo en Wumpus! ¡Pruébalo en Cardinal! Pruébalo en cera de abejas! Pruébalo en Alice!

¡Verificación!

Muchos lenguajes 2D, todos abusan de los literales de cadena de envoltura. La diferencia en las salidas es así:

> <>, Gol> <> y Befunge-98 imprimen el código al revés (excepto el "), con los últimos tres caracteres en diferentes posiciones R*", O"*y "R*respectivamente. La cera de abejas también tiene el código al revés, pero los últimos tres caracteres están intercalados en la primera sección de la salida. Alice está mayormente al revés, excepto por todos los caracteres escapados ( ', \y ") movidos al frente en su lugar.

Wumpus es la única quine real, Fission coloca el "código al final del código en lugar del principio, y Cardinal coloca el código "entre el 0y 5cerca del comienzo.

Prueba de diferentes permutaciones

Explicaciones:

Befunge-98:

"  Wrapping string literal pushes all other characters + a space to the stack
 65*4+  Push " to the stack
      059*$!#.39*0j   Push 1,27 to the stack
                   p  Pops the top three values of the stack (27,1,34)
                    2+  Adds 2 to the space to make "
                      'Wk,@  Prints the top 88 characters of the stack and terminates

> <> y Gol> <>:

Para ser honesto, no hice mucho aquí. La única diferencia entre la ejecución de estos dos idiomas es el @comando, que rota los tres valores principales de la pila de diferentes maneras para cada idioma.

"  Wrapping string literal pushes all other characters to the stack
 65*4+  Push 34 (") to the stack
      059*$!#.  Jump to cell 45,0
                                   \@  Rotate the top three values of the stack 
                                     ol?!,'.'0.  Output the whole stack, ending in a divide by 0/stack underflow error

Fisión:

 "............R  Spawn a pointer going right

 "  Switch to printing mode and print every other character
 "  Switch off printing mode
  6  Teleport to other 6
 "........6'!+O   Print the "

Wumpus:

"  Bouncing string literal
 65*4+  Push a (")
      059*$!#.   Push 0 and jump to cell 0,45
                                        \  Reflect off mirror
                                       +   Add 0 to top of stack
                                 @o&88#    Print the top 88 characters of the stack

Cardenal:

                                 %   Spawn two pointer going left/right (up/down despawn immediately)
                                  -$  Right pointer jumps to cell -1,0
                      x,++tttt=++     Left pointer prints "
"  While right pointer switches to print mode and prints the code

Cera de abejas:

 "................*`*   Spawn pointers going in every direction
                        Every other * also spawns pointers, but they do nothing
                   `    Turn on print mode for two of the pointers going in different directions
                        This prints everything but the `
          #}.6~.F4*     Print a `

Alicia:

"  Wrapping string literal pushes all other characters to the stack
   Except 's and mirrors
 65*4+  Push " to the stack
      059*$!#.  Does nothing
              39*0j  Jumps to cell 39,0
                         ''5&.    Push ' and duplicate it 5 times
                              '\  Push \
                                d&o@  Print the whole stack
Jo King
fuente
6

Perl 5 , rubíes , JavaScript (cromo), PHP , Python 2 , Python 3 , 1206 bytes, la puntuación 6 6 / 1,206 = 38,6865671641791

q=1//2;s=+0;s|0;"/.__id__;#";_="""q=1//2;s=+0;s|0;"/.__id__;#";_={0}{1}{0};R=chr((39,34)[1/2>0])*12;Q=chr((39,34)[1/2==0])*3;q={0}{2}{0};print(_.format(Q,_,q[0:-12]+R,"%"))""";R=chr((39,34)[1/2>0])*12;Q=chr((39,34)[1/2==0])*3;q="""|;#<?ob_end_clean();
eval($_='"$t"?0?[$q=37 .chr+113 .chr+38 .chr,$p=(96 .chr+39 .chr)*4,$n=10 .chr,$s=39 .chr*12,$S=34 .chr*3]:eval("printf=console.log;c=String.fromCharCode;$q=c(96);$p=c(37,113,38,39).repeat(4);$n=c(10);$s=c(39).repeat(12);$S=c(34,34,34)"):[]?[$q=q(!g)^PA,$p=HARHARHARHAR^od2od2od2od2,$n=R^X,$s=bbbbbbbbbbbb^EEEEEEEEEEEE,$S=hhh^JJJ]:[$q=O^h,$p=str_repeat(RHa3^w9GS,4),$n=R^X,$s=str_repeat(b^E,12),$S=HHH^jjj];//#');printf($x='q=1//2;s=+0;s|0;"/.__id__;#";_=%7$sq=1//2;s=+0;s|0;"/.__id__;#";_={0}{1}{0};R=chr((39,34)[1/2>0])*12;Q=chr((39,34)[1/2==0])*3;q={0}{2}{0};print(_.format(Q,_,q[0:-12]+R,"%8$s"))%7$s;R=chr((39,34)[1/2>0])*12;Q=chr((39,34)[1/2==0])*3;q=%7$s|;#<?ob_end_clean();%5$seval($_=%3$s%1$s%3$s);printf($x=%3$s%2$s%3$s,$_,$x,$q,$p,$n,$s,$S,"%8$s",![]||([]+[])?$n:"");//#%4$s%6$s%7$s;print(_.format(Q,_,q[0:-12]+R,"%8$s"))%9$s',$_,$x,$q,$p,$n,$s,$S,"%",![]||([]+[])?$n:"");//#`q&%`q&%`q&%`q&%''''''''''''""";print(_.format(Q,_,q[0:-12]+R,"%"))

¡Valide Perl, Ruby, PHP, Python 2 y Python 3 en línea!

Nota : ejecutar el programa anterior en la consola del Inspector en Chrome (que parece admitir argumentos posicionales console.log) devuelve el programa correcto.

Explicación

Esto resultó mucho más de lo que esperaba y también hice mi vida un poco más difícil, por lo que es probable que siga jugando. También me gustaría agregar más idiomas, pero necesito encontrar algo que no le $importe un sigilo ...

Esto es más o menos un formato estándar quine donde el cálculo de la cotización de uso es un poco diferente para cada idioma: en Ruby %q&se utiliza, utiliza PHP ', JavaScript (Node.js) hace uso de `y Perl 5 utiliza q(... ). Debido a que solo cambian las comillas, el resto del programa todavía es ejecutable y una sintaxis válida en cada idioma. Python 2 y 3 se envuelven alrededor del programa anterior usando """Python 2 y '''Python 3.

Los programas Perl y Ruby resultantes no son quines estándar, se agregan q/ %qs adicionales en cada iteración, pero el primer programa regresa correctamente.

Los resultados son:

  • Perl 5:
    eval($_=q&... q&);printf($x=q&... q&,... );//#'%`'%`'%`'%`''''''''''''"""...
  • Ruby:
    eval($_=%q&... %q&);printf($x=%q&... %q&,... );//#`'`'`'`'''''''''''''"""...
  • JavaScript (Chrome):
    eval($_=`... `);printf($x=`... `,... );//#%q&'%q&'%q&'%q&'''''''''''''"""...
  • PHP:
    eval($_='... ');printf($x='... ',... );//#`q&%`q&%`q&%`q&%''''''''''''"""...
  • Python 2:
    ... _="""... """;... q="""...''''''''''''""";print(_.format(Q,_,q[0:-12]+R,"%"))
  • Python 3:
    ... _='''... ''';... q='''...""""""""""""''';print(_.format(Q,_,q[0:-12]+R,"%"))

He reelaborado mucho esto, espero no haber perdido nada clave aquí. Todavía tengo mucho camino por recorrer para estar cerca del puntaje de Jo King ...

Dom Hastings
fuente
2

Jelly , y M , 2 6 /14 = 4,57

1Ɗṙ@“1Ɗṙ@ȮṾ”ȮṾ

Pruébalo en gelatina!

Pruébalo en M!

Ɗṙ@ȮṾ1“Ɗṙ@ȮṾ1” en gelatina

1Ɗṙ@ȮṾ“1Ɗṙ@ȮṾ” En m

dylnan
fuente
No estoy seguro de que el carbón de leña cuente como una quine adecuada
H.PWiz
@ H.PWiz Estaba a punto de agregar un comentario que decía eso. Le preguntaré a OP
dylnan el
@ l4m2 ¿considera el programa de carbón una quine adecuada? Eliminaré si no.
dylnan
Supongo que es como Quineen PHP?
l4m2
@ l4m2 No estoy seguro, no sé PHP. Funciona para la mayoría de los textos ASCII, creo
dylnan
2

Python 2 y Python 3 , 2 6 /61 = dispone 1.05

s='s=%r;print(s%%s[::(1/2>0)*2-1])';print(s%s[::(1/2>0)*2-1])

¡Pruébalo en Python 2!

¡Pruébalo en Python 3!

Guardado 12 bytes gracias a Jo King.

Python 2 impresiones

s=')]1-2*)0>2/1(::[s%%s(tnirp;r%=s';print(s%s[::(1/2>0)*2-1])

Python 3 impresiones

s='s=%r;print(s%%s[::(1/2>0)*2-1])';print(s%s[::(1/2>0)*2-1])

Esto utiliza el hecho de que 1/2está .5en Python 3 y 0en Python 2.

dylnan
fuente
1

Bash / GolfScript, 72 bytes, puntuación 2 6 /72 = 8/9 (~ 0,888 ...)

.~0 () 
{ 
    declare "-f" @* ".~0" " ()
 "+@n.;
    echo '.~0;'
}
.~0;

Contiene un solo espacio final en las dos primeras líneas.

Pruébelo en línea en Bash.
Pruébelo en línea en GolfScript.

Simplemente modificación de la respuesta de @ jimmy23013 para el desafío " Escribir una poliquina " . La modificación que se realizó fue eliminar el espacio final después de la tercera línea y cambiar \n"+@n.;a \n "+@n;.

Bash imprimirá las líneas 1 y 2 de esta manera:

.~0 ()    <- Trailing space
{         <- Trailing space

Y GolfScript imprimirá las líneas 1 y 2 de esta manera:

.~0 ()   <- No trailing space
 {       <- Both leading and trailing space

Aquí el programa base, la salida Bash y las salidas GolfScript respectivamente con las nuevas líneas reemplazadas por \n:

.~0 () \n{ \n    declare "-f" @* ".~0" " ()\n "+@n.;\n    echo '.~0;'\n}\n.~0;
.~0 () \n{ \n    declare "-f" @* ".~0" " ()\n "+@n.;\n    echo '.~0;'\n}\n.~0;
.~0 ()\n { \n    declare "-f" @* ".~0" " ()\n "+@n.;\n    echo '.~0;'\n}\n.~0;

      ^^^ Note the difference here
Kevin Cruijssen
fuente