¡Golf un Double Quine por un bien mayor!

18

Buenas noches, damas y caballeros.

Esta noche, tenemos un desafío de código. Una competencia que se definirá no en la cantidad de puntos (a la Asteroides) sino simplemente si puedes terminarla (a la Zelda). Y en aras de la comparación, la cantidad de bytes (uh ... pero dijiste ...).

Su desafío es componer una quine única que se compila tanto en WhiteSpace como en cualquier otro idioma de su elección. Ambas quines deben tener una salida absolutamente idéntica (que como quine es absolutamente idéntica al código fuente). Su quine debe tener más de 3 bytes de longitud.

Su puntaje es el tamaño de su código fuente en bytes.

Dado que este desafío involucra WhiteSpace, por favor, escape de sus respuestas para que sean claras, preferiblemente en el estilo C. Su puntaje es la fuente original en bytes, no la versión escapada.

Buena suerte.

lochok
fuente
1
¿ Haría un volcado hexadecimal xxd ?
Ilmari Karonen
Si. Lo aceptaré
lochok

Respuestas:

19

Espacio en blanco y Perl, 992 975 caracteres

Buenas tardes damas y caballeros.

Para empezar, aquí está mi envío codificado en base64, que creo que es la mejor manera de comunicar un gran programa de espacios en blanco. (Realmente no desea utilizar una codificación que deje cualquier espacio en blanco tal como está, por lo que no tiene sentido seleccionar algo más "legible").

c2F5PDwgeDI7c2F5PDwwLDAgIApzYXk8PCB4MjtzYXk8PDAsMCAgCgoJCQogICAJCSAgCSAgCSAJ
CSAgCSAgCQkgCSAJIAkJCQkJICAJCSAJCQkgCQkJCQkgCSAJIAkJIAkgCSAgIAkJCQkJICAgCQkg
IAkgCQkgCSAJCSAJICAgIAkJCQkgCSAgCSAJCSAJICAgIAkgCQkgICAJICAgICAgCQkJIAkJCQkJ
IAkJCSAJCQkJICAgICAJCQkgCSAgICAgIAkJCQkJICAgICAgCQkgICAJCSAgICAJCQkJCQkJCSAg
CSAJIAkgICAJCQkgICAJCQkJCSAgCQkJCSAJICAgIAkgCQkJCQkgCSAgICAgCSAgCSAJICAgICAg
CSAgICAJICAgICAJCSAgIAkJCSAJIAkJCQkJCSAJCSAJIAkgICAgICAgCQkgIAkgICAgICAgICAg
IAkJICAgCSAJCQkgCSAgICAgCQkJCQkJIAkgICAgCQkJCSAJCQkJICAJCQkgICAJCQkgCSAgCSAg
IAkJCQkgIAkJIAkJCSAgIAkJCSAJCQkgCQkJICAJCSAJICAJIAkJCSAJIAkgCQkgICAgIAkgCSAJ
ICAJICAJIAkJICAgICAJIAkgICAgCQkJCSAgCSAJCSAJIAkJIAkgIAkgCSAJCSAJCSAJCSAJCQkg
CQkJICAgIAkJCSAgCSAgCQogICAJICAgICAJCQkJCSAJCSAJIAkgCSAJICAJCQkgICAJICAgCSAg
ICAJCSAJICAgICAgICAgCSAgIAkJCQkgCQkgICAgCQkgCSAJICAJCQkgCQkJCSAJCQkgICAJICAg
IAkgCSAJCQkgIAkJCQkgCSAJCSAJIAkgCQkJCSAJICAJIAkJIAkgICAJCiAKICAKICAgIAogCSAg
CQoKICAJCiAKICAgIAkJCQkgCSAKCSAJCQkKICAgICAJCQkJIAkgCgkgCSAgCiAgIAkJCgkgIAoK
CQkJCiAKCgoJIAkKICAgCSAgIAkgIAoKIAkKIAkgIAkKCiAJIAogICAJIAoKIAkKCiAJIAoKIAkK
CQogCSAgIAkgCgogCQoKCgoKICAgCiAgIAogCiAKIAkKCiAJCgogICAgCiAKIAoJIAogCiAgICAJ
IAoJIAkJIAoJICAgCSAKCSAJIAogCSAgCgogIAogCiAgICAJCQoJIAkJICAJCSAJCQkKCSAgCiAg
CQkJICAgCgkgCQkgICAJICAgICAKCSAgIAkKICAgICAJCQoJIAkgIAogICAJCQoJICAKCgkJCiAK
CgoJCjAK

Aquí hay un extracto que resalta todas las partes visibles de la fuente. se usa para indicar una pestaña y para indicar una nueva línea.

say<< x2;say<<0,0  ↲
say<< x2;say<<0,0  ↲
↲
⇥⇥↲
   ⇥⇥  ⇥ [... etcetera ... skipping rest of a really long line ...]↲
   ⇥⇥⇥ ⇥⇥[... etcetera ... shorter but still quite a long line ...]↲
 ↲
  ↲
    ↲
 ⇥  ⇥↲
[... etcetera ... whole lotta whitespace in here ...]
⇥⇥↲
 ↲
↲
↲
⇥↲
0↲

Perl fue la elección natural para el segundo idioma en este desafío, siendo uno de los mejores lenguajes de uso general para escribir quines compactas. Mi quine más corto de Perl es de 19 bytes:

say<< x2
say<< x2
 

- y puedes ver cómo fue la semilla de la mitad Perl del doble quine. Mi mejor quine de espacios en blanco, en comparación, tiene 541 bytes de longitud. (Aunque existen los más cortos, 445 bytes es lo mejor que he visto).

Desde el punto de vista del intérprete de Perl, la primera línea del archivo fuente de la doble quine contiene las dos declaraciones que componen todo el programa propiamente dicho, ya que los contenidos restantes son dos cadenas citadas. La primera cadena es la línea repetida de Perl, y está delimitada por la tercera línea en blanco. La segunda cadena es todo espacio en blanco, y se extiende desde la cuarta línea de la fuente hasta el 0delimitador en la parte inferior del archivo.

Cuando se toma como un programa de espacios en blanco, las primeras cuatro líneas contienen tres instrucciones que son en gran medida inútiles. (Su efecto es insertar dos valores cero en la pila, y luego descartar el segundo). Se incluyen solo para superar con seguridad las nuevas líneas que requiere el programa Perl; el programa real comienza después de eso. En lugar de citar la fuente ilegible, aquí hay una paráfrasis de las instrucciones que componen el programa Whitespace, en un formato similar al ensamblado:

# Representation of "say<< ;say<<0,0  \n" in base 122 as ASCII chars.
PERLCODE = 44892457841068708924520433691075560592081

# Represention of the whitespace program, following the "push PERLCODE"
# instruction, in base 3 (see comments on wsout).
WSCODE = 9823454421986355730445143846606456399449033186160554878002671428613111806443504867738858766142050504887335990409088441824104338753030405625930185

# Set up the stack and the heap. The first three instructions are not
# particularly useful; they're just there to skip past the newlines in
# the Perl code. (Though the initial zero on the stack does get used
# at the very end.)

        push    0
        push    0
        jneg    wsout

        push    WSCODE
        push    PERLCODE
        dup
        dup
        push    0
        copy    1

# Output the first four lines of the file.

perl:   dup
        mod     122
        putchar
        div     122
        dup
        jnzero  perl
        pop
        jzero   perl
        push    68              # represents "jneg wsout"
        call    wsout

# Output the rest of the file.

        copy    1
        call    pushout
        push    2
        call    wsout
        call    pushout
        call    wsout
        putnum
        push    2
        call    wsout
        exit

# pushout: Output a Whitespace push instruction, using the number on
# the top of the stack as the instruction's argument. (Recursion is
# used to output the bits MSB-first.)

pushout:
        push    0
        dup
        call    wsout
        call    wsout
bits:   dup
        jzero   bitend
        dup
        mod     2
        swap
        div     2
        call    bits
bitend: call    wsout
        ret

# wsout: Output a sequence of whitespace characters as represented by
# the number on the top of the stack. The number is read in base 3,
# LSB-first, with 0 = SPC, 1 = TAB, 2 = NL. Calling wsout with a value
# of zero will output a single space.

wsout:
        dup
        mod     3
        mul     -23             # some ugly math that transforms
        mod     -24             # (0, 1, 2) into (32, 9, 10)
        add     32
        putchar
        div     3
        dup
        jnzero  wsout
        pop
        ret

Los números gigantes en la parte superior son lo que los usuarios de Whitespace tenemos que usar en lugar de cadenas reales. No se moleste en intentar ejecutar esto en un intérprete de espacios en blanco que no tenga soporte bignum adecuado.

Finalmente, aquí está el programa nuevamente, pero esta vez con escapes de estilo C, ya que se solicitó específicamente:

say<< x2;say<<0,0  \nsay<< x2;say<<0,0  \n\n\t\t\n   \t\t  \t  \t \t\t  \t  \t\t \t \t \t\t\t\t\t  \t\t \t\t\t \t\t\t\t\t \t \t \t\t \t \t   \t\t\t\t\t   \t\t  \t \t\t \t \t\t \t    \t\t\t\t \t  \t \t\t \t    \t \t\t   \t      \t\t\t \t\t\t\t\t \t\t\t \t\t\t\t     \t\t\t \t      \t\t\t\t\t      \t\t   \t\t    \t\t\t\t\t\t\t\t  \t \t \t   \t\t\t   \t\t\t\t\t  \t\t\t\t \t    \t \t\t\t\t\t \t     \t  \t \t      \t    \t     \t\t   \t\t\t \t \t\t\t\t\t\t \t\t \t \t       \t\t  \t           \t\t   \t \t\t\t \t     \t\t\t\t\t\t \t    \t\t\t\t \t\t\t\t  \t\t\t   \t\t\t \t  \t   \t\t\t\t  \t\t \t\t\t   \t\t\t \t\t\t \t\t\t  \t\t \t  \t \t\t\t \t \t \t\t     \t \t \t  \t  \t \t\t     \t \t    \t\t\t\t  \t \t\t \t \t\t \t  \t \t \t\t \t\t \t\t \t\t\t \t\t\t    \t\t\t  \t  \t\n   \t     \t\t\t\t\t \t\t \t \t \t \t  \t\t\t   \t   \t    \t\t \t         \t   \t\t\t\t \t\t    \t\t \t \t  \t\t\t \t\t\t\t \t\t\t   \t    \t \t \t\t\t  \t\t\t\t \t \t\t \t \t \t\t\t\t \t  \t \t\t \t   \t\n \n  \n    \n \t  \t\n\n  \t\n \n    \t\t\t\t \t \n\t \t\t\t\n     \t\t\t\t \t \n\t \t  \n   \t\t\n\t  \n\n\t\t\t\n \n\n\n\t \t\n   \t   \t  \n\n \t\n \t  \t\n\n \t \n   \t \n\n \t\n\n \t \n\n \t\n\t\n \t   \t \n\n \t\n\n\n\n\n   \n   \n \n \n \t\n\n \t\n\n    \n \n \n\t \n \n    \t \n\t \t\t \n\t   \t \n\t \t \n \t  \n\n  \n \n    \t\t\n\t \t\t  \t\t \t\t\t\n\t  \n  \t\t\t   \n\t \t\t   \t     \n\t   \t\n     \t\t\n\t \t  \n   \t\t\n\t  \n\n\t\t\n \n\n\n\t\n0\n
caja de pan
fuente
2
¡Guauu! Pensé que el brainfuck sería la primera solución.
Boothby
1
Lo pensé, pero el problema es que las quines Brainfuck son incluso más largas que las quinas de espacios en blanco. Entre los dos, el resultado habría sido enorme.
breadbox