Golf Sie ein Double Quine für mehr Gutes!

18

Guten Abend meine Damen und Herren.

Heute Abend haben wir eine Code-Herausforderung. Ein Wettbewerb, der nicht in der Anzahl der Punkte (a la Asteroids) definiert wird, sondern nur, ob Sie ihn beenden können (a la Zelda). Und zum Vergleich die Anzahl der Bytes (äh ... aber du hast gesagt ...).

Ihre Herausforderung besteht darin, ein einzelnes Quine zu erstellen, das sowohl in WhiteSpace als auch in jeder anderen Sprache Ihrer Wahl kompiliert werden kann . Beide Quines müssen eine absolut identische Ausgabe haben (was als Quine absolut identisch mit dem Quellcode ist). Ihr Quine muss mehr als 3 Bytes lang sein.

Ihre Punktzahl entspricht der Größe Ihres Quellcodes in Byte.

In Anbetracht der Tatsache, dass diese Herausforderung WhiteSpace umfasst, entziehen Sie sich bitte Ihren Antworten, damit sie klar sind - vorzugsweise im C-Stil. Ihre Punktzahl ist die ursprüngliche Quelle in Bytes - nicht die maskierte Version.

Viel Glück.

Lochok
quelle
1
Würde ein xxd- Hex-Dump helfen ?
Ilmari Karonen
Ja. Ich werde es akzeptieren.
Lochok

Antworten:

19

Whitespace und Perl, 992 975 Zeichen

Guten Abend meine Damen und Herren.

Zunächst ist hier meine in base64 codierte Einreichung, die meiner Meinung nach die beste Möglichkeit ist, ein großes Whitespace-Programm zu kommunizieren. (Sie möchten wirklich keine Codierung verwenden, bei der Leerzeichen unverändert bleiben. Es macht also keinen Sinn, etwas "lesbareres" auszuwählen.)

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

Hier ist ein Auszug, der alle sichtbaren Teile der Quelle hervorhebt. wird verwendet, um einen Tabulator und eine neue Zeile anzugeben.

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 war die natürliche Wahl für die zweite Sprache in dieser Herausforderung, da es eine der besten Allzwecksprachen für das Schreiben kompakter Quines war. Meine kürzeste Perl-Quine ist 19 Bytes:

say<< x2
say<< x2
 

- und Sie können sehen, wie es der Same für die Perl-Hälfte des Doppelquins war. Mein bester Whitespace-Quine ist im Vergleich dazu 541 Byte lang. (Obwohl es kürzere gibt - 445 Bytes sind die besten, die ich je gesehen habe.)

Aus Sicht des Perl-Interpreters enthält die erste Zeile der Quelldatei der doppelten Quine die beiden Anweisungen, aus denen das gesamte eigentliche Programm besteht, da der verbleibende Inhalt zwei in Anführungszeichen gesetzte Zeichenfolgen sind. Die erste Zeichenfolge ist die wiederholte Zeile von Perl und wird durch die leere dritte Zeile begrenzt. Die zweite Zeichenfolge besteht ausschließlich aus Leerzeichen und wird von der vierten Zeile der Quelle bis zum 0Begrenzer am Ende der Datei ausgeführt.

Als Whitespace-Programm enthalten die ersten vier Zeilen drei Befehle, die weitgehend unbrauchbar sind. (Ihre Wirkung besteht darin, zwei Nullwerte auf den Stapel zu schieben und den zweiten zu verwerfen.) Sie sind nur enthalten, um sicher über die Zeilenumbrüche hinwegzukommen, die das Perl-Programm erfordert - das eigentliche Programm startet danach. Anstatt die unlesbare Quelle weiter zu zitieren, finden Sie hier eine Zusammenfassung der Anweisungen, aus denen sich das Whitespace-Programm zusammensetzt, in einem Assembly-ähnlichen Format:

# 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

Die riesigen Zahlen an der Spitze sind das, was Whitespace-Benutzer anstelle von tatsächlichen Zeichenfolgen verwenden müssen. Versuchen Sie nicht, dies auf einem Whitespace-Interpreter auszuführen, der keine angemessene Bignum-Unterstützung bietet.

Zum Schluss nochmal das Programm, diesmal jedoch mit C-Style Escape, da es ausdrücklich angefordert wurde:

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
Brot-Box
quelle
2
Wow! Ich dachte, Brainfuck wäre die erste Lösung.
Stand
1
Ich habe darüber nachgedacht, aber das Problem ist, dass Brainfuck-Quines sogar länger sind als Whitespace-Quines. Zwischen den beiden wäre das Ergebnis gewaltig gewesen.
Brotkasten