Ihre Herausforderung ist einfach. Schreiben Sie zwei Programme, die keine Zeichen gemeinsam haben, die sich gegenseitig ausgeben.

Beispiel

Zwei Programme P und Q schließen sich gegenseitig aus, wenn:

1. P gibt Q aus
2. Q gibt P aus
3. Es gibt kein Zeichen c, das sowohl zu P als auch zu Q gehört
4. Jedes Programm P und Q sind richtige Quines
   1. Dies zählt leere Quines und Quines, die ihren eigenen (oder den des anderen) Quellcode als ungültig lesen .

Weitere Regeln

• Die kürzeste kombinierte Länge dieser Programme gewinnt. Das heißt, Größe ( P ) + Größe ( Q ) ist Ihre Punktzahl, und die niedrigste Punktzahl gewinnt.
• Beide Programme sind in derselben Sprache
• Jedes Programm kann ein vollständiges Programm oder eine vollständige Funktion sein und muss nicht identisch sein.
  • Beispielsweise kann P ein vollständiges Programm sein und Q kann eine Funktion sein.

Nachprüfung

Diese Versuchen Sie es online! Hier können Sie überprüfen, ob sich zwei Programme gegenseitig ausschließen. Die Eingaben werden in die ersten beiden Argumente eingefügt.

> <> , Ergebnis: 41 + 41 = 82

Edit: beide enthielten eine 3. Behoben

'd3*}>a!o-!<<8:5@lI55>@z:5ll55>>q:>|q::|,

und

"r00gr40g44++bb+0p64++?b6+0.22#eW4s )Z

Probieren Sie es online! (Vertauschen Sie die Zeilen, um die andere Ausgabe zu erhalten.) Diesmal mit Bestätigung!

><>ist eine besonders schwierige Sprache, da es nur einen Weg gibt, Zeichen auszugeben, den Befehl o. Glücklicherweise können wir den Befehl p ut overwenden, um während der Ausführung einen Code in den Quellcode einzufügen, wie in meiner Antwort Programmierung in einer unberührten Welt .

Dieser hat eine Menge Versuch und Irrtum gekostet. Ich habe mit den beiden sich gegenseitig ausschließenden Programmen begonnen:

'd3*}>N!o-!<<data

und

"r00gr40g8+X0pN+?Y0.data

Jeder transformiert sich und seine Daten um N, der erste subtrahiert und der zweite addiert. Dies gibt es dann umgekehrt aus. Der Punkt ist , dass die Daten nach jedem Programm ist das andere Programm in umgekehrter Richtung, verschoben durch N. ( Xwird die Zellnummer , wo das Programm die Anforderungen zu setzen ound Y ist die Zelle , in der der Zeiger auf der Schleife zurück. ?Ist , wo das oist gesetzt) .

Beide folgen derselben Struktur, die auf unterschiedliche Weise dargestellt wird. Sie führen ein Zeichenfolgenliteral über den gesamten Code aus und fügen es dem Stapel hinzu. Sie erstellen den von ihnen verwendeten String-Literal-Befehl neu und platzieren ihn unten im Stapel. Sie durchlaufen den Stapel, addieren / subtrahieren N zu jedem Zeichen und drucken sie.

Das erste Programm verwendet 'als String-Literal und das einfach d3*}zu erstellende den Wert 39 und schiebt ihn an den unteren Rand des Stapels. Der zweite verwendet "als String das Literal mit der gleichen Funktion. Es rwird der Stapel gumgedreht, das Zeichen in Zelle 0,0 gesetzt und der Stapel erneut umgekehrt. Es setzt dann gden Wert in Zelle 4,0 ( g) und addiert 8 dazu, um den Wert oin X zu erhalten.

Beide Programme verwenden eine andere Schleifenmethode. Das erste Programm verwendet den Befehl überspringen ( !), um nur die Hälfte der Anweisungen auszuführen, während Sie nach links gehen, die Richtung umkehren und die andere Hälfte ausführen. Der zweite Befehl verwendet den Sprungbefehl ( .), um zum Anfang der Schleife in Zelle Y zurückzuspringen. Beide werden ausgeführt, bis keine Elemente mehr auf dem Stapel und die Programmfehler vorhanden sind.

Ich hatte eine Reihe von Problemen mit den meisten niedrigeren Werten von N, weil das Verschieben eines Zeichens es in ein anderes für dieses Programm wesentliches Zeichen (und daher nicht als Daten für das andere Programm verwendet werden kann) oder in zwei Zeichen aus dem verwandeln würde zwei Programme würden sich in den gleichen Charakter verwandeln. Beispielsweise:

1. ++1 = ,= --1
2. .+2 = 0
3. *= --3
4. g+4 = k= o-4

etc.

Irgendwann bekam ich 10 ( a), wo ich diese Probleme vermeiden konnte. Es könnte eine kürzere Version geben, in der die Verschiebungen umgekehrt sind und das erste Programm N addiert, während das zweite es subtrahiert. Dies könnte jedoch schlimmer sein, da sich das erste Programm im Allgemeinen am unteren Ende der ASCII-Skala befindet. Daher ist das Subtrahieren besser, um Konflikte zu vermeiden.

Forth (64-Bit-Little-Endian-Gforth) , 428 + 637 = 1065 Bytes

s"	:	l	bl	-	;	:	m	l	emit	;	:	s	space	;	:	z	m	m	m	m	s	;	:	p	.	't	'i	'm	'e	z	;	'e	'r	'e	'h	z	:	q	>r	char	l	bl	l	do	dup	@	.	'L	m	s	cell+	loop	r>	.	;	:	n	'e	'p	'y	't	z	;	q	;	's	p	'B	l	p	#tab	p	'p	'u	'd	'Q	char+	z	n	'B	l	p	n":	l	bl	-	;	:	m	l	emit	;	:	s	space	;	:	z	m	m	m	m	s	;	:	p	.	't	'i	'm	'e	z	;	'e	'r	'e	'h	z	:	q	>r	char	l	bl	l	do	dup	@	.	'L	m	s	cell+	loop	r>	.	;	:	n	'e	'p	'y	't	z	;	q	;	's	p	'B	l	p	#tab	p	'p	'u	'd	'Q	char+	z	n	'B	l	p	n

HERE 3245244174817823034 , 7784873317282429705 , 665135765556913417 , 7161128521877883194 , 682868438367668581 , 679209482717038957 , 680053688600562035 , 678116140452874542 , 682868623551327527 , 680649414991612219 , 682868636436227367 , 7136360695317203258 , 7809815063433470312 , 8458896374132993033 , 5487364764302575984 , 7810758020979846409 , 680166068077538156 , 4181938639603318386 , 8081438386390920713 , 8793687458429085449 , 2812844354006760201 , 7784826166316108147 , 676210045490917385 , 681493840106293616 , 7521866046790788135 , 679491013524025953 , 7928991804732031527 , 216 115 EMIT 34 EMIT 9 EMIT 2DUP TYPE 34 EMIT TYPE 

Probieren Sie es online!

Überprüfungsskript

Vielen Dank an @ Nathaniel für die Idee, Forth zu verwenden - er erinnerte mich in den Kommentaren daran, dass bei Forth nicht zwischen Groß- und Kleinschreibung unterschieden wird . Dann gab es Stimmungsschwankungen - ich habe Gründe gefunden, warum dies nicht funktioniert, gefolgt von immer wieder neuen Lösungen für diese Probleme. Während ich mein Indoor-Trainingsrad wie einen übergroßen und unförmigen Zappel-Spinner drehte (Sie müssen nur ein Ende des Lenkers greifen und ihn ein wenig neigen).

Vor dem Schreiben dieser Programme habe ich ausgearbeitet, welche Zeichen von welchem ​​Programm verwendet werden können. Insbesondere kann das zweite Programm nur Großbuchstaben, Dezimalstellen, Tabulatoren und Kommas verwenden. Dies würde bedeuten, dass das erste Programm nur Kleinbuchstaben enthält, aber ich habe einige Großbuchstaben für die ASCII-Werte verwendet.

Da Tabulatoren unhandlich sind, werde ich stattdessen Leerzeichen in der Erklärung verwenden.

Das erste Programm hat die Form s" code"code- das s"startet ein String-Literal, das dann von der zweiten Kopie des Codes verarbeitet wird - ein Standard-Quine-Framework. Anstatt jedoch einen eigenen Quellcode auszugeben, wird das andere Programm erstellt, das wie folgt aussieht:

• HERE
• Für jeweils 8 Bytes in der ursprünglichen Zeichenfolge 64-bit-number-literal ,
• length-of-the-string
• 115 EMIT 34 EMIT 9 EMIT 2DUP TYPE 34 EMIT TYPE

Dies verwendet den Datenraum von Forth. HEREGibt den Zeiger an das Ende des aktuell zugewiesenen Datenbereichs zurück und ,hängt eine Zelle an, die mit einer Nummer gefüllt ist. Daher werden die ersten drei Aufzählungspunkte als String-Literal angezeigt, das mit erstellt wurde s". So beenden Sie das zweite Programm:

• EMIT gibt ein Zeichen mit seinem ASCII-Wert aus.
  • 115 EMIT druckt einen Kleinbuchstaben s
  • 34 EMIT druckt das Anführungszeichen "
  • 9 EMIT druckt eine Registerkarte
• 2DUPdupliziert die beiden obersten Elemente auf dem Stapel ( a b -- a b a b ), hier ist es der Zeiger auf und die Länge des Strings
• TYPE Gibt eine Zeichenfolge aus, um die erste Kopie des Codes auszugeben
• 34 EMITdruckt das abschließende Zitat "und schließlich
• TYPE gibt die zweite Kopie des Codes aus

Mal sehen, wie das erste Programm funktioniert. In vielen Fällen haben Zahlen vermieden werden, was die erfolgt über 'xgforth Syntax - Erweiterung für Zeichenliterale, und manchmal den ASCII - Wert des Raumes subtrahieren, die unter Verwendung erhalten werden kann bl:

s" ..."      \ the data
: l bl - ;   \ define a word, `l`, that subtracts 32
: m l emit ; \ define a word, `m`, that outputs a character. Because 32 is
             \ subtracted using `l`, lowercase characters are converted to
             \ uppercase, and uppercase characters are converted to some
             \ symbols, which will become useful later
: z m m m m space ; \ `z` outputs four characters using `m`, followed by a
                    \ space. This is very useful because all words used in the
                    \ second program are four characters long
: p . 't 'i 'm 'e z ; \ define a word, `p`, that, given a number, outputs that
                      \ number, followed by a space, `EMIT`, and another space
'e 'r 'e 'h z \ here is where outputting the second program starts - `HERE `
: q \ define a helper word, `q`, that will be called only once. This is done
    \ because loop constructs like do...loop can't be used outside of a word.
  >r \ q is called with the address and the length of the data string. >r saves
     \ the length on the return stack, because we don't need it right now. While
     \ it might seem like this is too complicated to be the best way of doing
     \ this for codegolf, just discaring the length would be done using four
     \ characters - `drop`, which would give you the same bytecount if you could
     \ get the length again in... 0 characters.
  char l \ get a character from after the call to q, which is `;`, with the
         \ ASCII value of $3B, subtract $20 to get $1B, the number of 64-bit
         \ literals necessary to encode the string in the second program.
  bl l \ a roundabout way to get 0
  do   \ iterate from 0 (inclusive) to $1B (exclusive)
    \ on the start of each iteration, the address of the cell we are currently
    \ processing is on the top of the stack.
    dup @ . \ print the value. The address is still on the stack.
    'L m space \ the ASCII value of L is exactly $20 larger than the one of ,
    cell+ \ go to the next cell
  loop
  r> . \ print the length of the string
;
: n 'e 'p 'y 't z ; \ define a word, `n`, that outputs `TYPE`
q ; \ call q, and provide the semicolon for `char` (used to encode the length
    \ of the string in 64-bit words). Changing this to an uppercase U should
    \ make this work on 32-bit systems, but I don't have one handy to check that
's p \ print the code that outputs the lowercase s
'B l p \ likewise, 'B l <=> $42 - $20 <=> $22 <=> the ASCII value of a comma
#tab p \ print the code that outputs a tab
'p 'u 'd 'Q char+ z \ char+ is the best way to add 1 without using any digits.
                    \ it is used here to change the Q to an R, which can't be
                    \ used because of `HERE` in the second program. R has an
                    \ ASCII value exactly $20 larger than the ASCII value of 2,
                    \ so this line outputs the `2DUP`.
n 'B l p n \ output TYPE 34 EMIT TYPE to finish the second program. Note the
           \ that the final `n` introduces a trailing space. Trying to remove
           \ it adds bytes.

Abschließend möchte ich sagen, dass ich es mit versucht habe EVALUATE, aber das zweite Programm wird größer als die beiden oben dargestellten. Wie auch immer, hier ist es:

: s s" ; s evaluate"s" : l bl - ; : m l emit ; : d here $b $a - allot c! ; : c here swap dup allot move ; : q bl l do #tab emit dup @ bl l u.r cell+ #tab emit 'L m loop ; here bl 'B l 's bl 's bl 'Z l d d d d d d d -rot c bl 'B l 's 'B l d d d d s c 'B l d c 'e 'r 'e 'h m m m m 'A q #tab emit 'e 'p 'y 't m m m m"; s evaluate

Wenn du es schaffst, so viel Golf zu spielen, dass meine s" ..."...Herangehensweise übertroffen wird , dann poste es als deine eigene Antwort.

Perl, (311 + 630 = 941 Bytes) 190 + 198 = 388 Bytes

Beide Programme drucken auf Standardausgabe.

Das erste Perl-Programm enthält meist druckbare ASCII-Zeichen und Zeilenumbrüche und endet in genau einer Zeile, die beiden Buchstaben ÿ stehen jedoch für das Nicht-ASCII-Byte \ xFF:

@f='^"ÿ"x92;@f=(@f,chr)for 115,97,121,36,126,191,153,194,216,113;print@f[1..5,5,10,5..9,0,9,0,5]'^"ÿ"x92;@f=(@f,chr)for 115,97,121,36,126,191,153,194,216,113;print@f[1..5,5,10,5..9,0,9,0,5]

Das zweite enthält hauptsächlich Nicht-ASCII-Bytes, einschließlich mehrerer High-Control-Zeichen, die in diesem Beitrag durch Sterne ersetzt werden, und überhaupt keine Zeilenumbrüche:

say$~~q~¿*ÂØ¡Ý*Ý*ÆÍÄ¿*Â׿*Ó***Ö***ßÎÎÊÓÆÈÓÎÍÎÓÌÉÓÎÍÉÓÎÆÎÓÎÊÌÓÎÆËÓÍÎÉÓÎÎÌÄ*****¿*¤ÎÑÑÊÓÊÓÎÏÓÊÑÑÆÓÏÓÆÓÏÓʢءÝ*Ý*ÆÍÄ¿*Â׿*Ó***Ö***ßÎÎÊÓÆÈÓÎÍÎÓÌÉÓÎÍÉÓÎÆÎÓÎÊÌÓÎÆËÓÍÎÉÓÎÎÌÄ*****¿*¤ÎÑÑÊÓÊÓÎÏÓÊÑÑÆÓÏÓÆÓÏÓÊ¢~

Ein Hexdump des ersten Programms mit xxdist:

00000000: 4066 3d27 5e22 ff22 7839 323b 4066 3d28  @f='^"."x92;@f=(
00000010: 4066 2c63 6872 2966 6f72 2031 3135 2c39  @f,chr)for 115,9
00000020: 372c 3132 312c 3336 2c31 3236 2c31 3931  7,121,36,126,191
00000030: 2c31 3533 2c31 3934 2c32 3136 2c31 3133  ,153,194,216,113
00000040: 3b70 7269 6e74 4066 5b31 2e2e 352c 352c  ;print@f[1..5,5,
00000050: 3130 2c35 2e2e 392c 302c 392c 302c 355d  10,5..9,0,9,0,5]
00000060: 275e 22ff 2278 3932 3b40 663d 2840 662c  '^"."x92;@f=(@f,
00000070: 6368 7229 666f 7220 3131 352c 3937 2c31  chr)for 115,97,1
00000080: 3231 2c33 362c 3132 362c 3139 312c 3135  21,36,126,191,15
00000090: 332c 3139 342c 3231 362c 3131 333b 7072  3,194,216,113;pr
000000a0: 696e 7440 665b 312e 2e35 2c35 2c31 302c  int@f[1..5,5,10,
000000b0: 352e 2e39 2c30 2c39 2c30 2c35 5d0a       5..9,0,9,0,5].

Und ein Hexdump des zweiten Programms ist:

00000000: 7361 7924 7e7e 717e bf99 c2d8 a1dd 00dd  say$~~q~........
00000010: 87c6 cdc4 bf99 c2d7 bf99 d39c 978d d699  ................
00000020: 908d dfce ceca d3c6 c8d3 cecd ced3 ccc9  ................
00000030: d3ce cdc9 d3ce c6ce d3ce cacc d3ce c6cb  ................
00000040: d3cd cec9 d3ce cecc c48f 8d96 918b bf99  ................
00000050: a4ce d1d1 cad3 cad3 cecf d3ca d1d1 c6d3  ................
00000060: cfd3 c6d3 cfd3 caa2 d8a1 dd00 dd87 c6cd  ................
00000070: c4bf 99c2 d7bf 99d3 9c97 8dd6 9990 8ddf  ................
00000080: cece cad3 c6c8 d3ce cdce d3cc c9d3 cecd  ................
00000090: c9d3 cec6 ced3 ceca ccd3 cec6 cbd3 cdce  ................
000000a0: c9d3 cece ccc4 8f8d 9691 8bbf 99a4 ced1  ................
000000b0: d1ca d3ca d3ce cfd3 cad1 d1c6 d3cf d3c6  ................
000000c0: d3cf d3ca a27e                           .....~

Im zweiten Programm ist die in Anführungszeichen gesetzte Zeichenfolge (189 Bytes lang, durch Tilden begrenzt) das gesamte erste Programm mit Ausnahme der letzten Newline, die nur durch bitweise Ergänzung jedes Bytes codiert wird. Das zweite Programm dekodiert einfach die Zeichenfolge, indem es jedes der Bytes ergänzt, was der ~Operator in Perl ausführt. Das Programm gibt den dekodierten String gefolgt von einer neuen Zeile aus (die sayMethode fügt eine neue Zeile hinzu).

Bei dieser Konstruktion verwendet der Decoder des zweiten Programms nur sechs verschiedene ASCII-Zeichen, so dass das erste Programm praktisch beliebig sein kann, solange es nur ASCII-Zeichen enthält und diese sechs Zeichen ausschließt. Es ist nicht schwer, ein Perl-Programm zu schreiben, ohne diese fünf Zeichen zu verwenden. Die eigentliche Quine-Logik befindet sich also im ersten Programm.

Im ersten Programm verwendet die Quine-Logik ein 11 Wörter langes Wörterbuch @fund setzt die Ausgabe dieser Wörter zusammen. Das erste Wort wiederholt den größten Teil des Quellcodes des ersten Programms. Der Rest der Wörter sind bestimmte Einzelzeichen. Beispielsweise ist Wort 5 eine Tilde, die das Trennzeichen für das Zwei-Zeichenfolgen-Literal im zweiten Programm ist. Die Liste der Zahlen in Klammern gibt an, welche Wörter in welcher Reihenfolge gedruckt werden sollen. Dies ist eine ziemlich gewöhnliche allgemeine Konstruktionsmethode für Quines. In diesem Fall besteht die einzige Verdrehung darin, dass die ersten Wörter des Wörterbuchs mit ihren Bytes bitweise komplementiert gedruckt werden.

Haskell , 306 + 624 = 930 Bytes

Programm 1: Eine anonyme Funktion, die ein Dummy-Argument verwendet und eine Zeichenfolge zurückgibt.

(\b c()->foldr(\a->map pred)b(show()>>c)`mappend`show(map(map fromEnum)$tail(show c):pure b))"İĴİóđđđÝöÝâÝæÝääē××êääē××İēÀħđĮâħēĕóİóòòĮááħááđéêâéêēááĮÀħ""(\b c()->foldr(\a->map pred)b(show()>>c)`mappend`show(map(map fromEnum)$tail(show c):pure b))"

Probieren Sie es online!

Programm 2: q[[40,...]]Am Ende steht eine anonyme Funktion, die ein Dummy-Argument verwendet und einen String zurückgibt.

z~z=[[['@','0'..]!!4..]!!z]
q[x,q]_=z=<<x++q++[34,34]++x
q[[40,92,98,32,99,40,41,45,62,102,111,108,100,114,40,92,97,45,62,109,97,112,32,112,114,101,100,41,98,40,115,104,111,119,40,41,62,62,99,41,96,109,97,112,112,101,110,100,96,115,104,111,119,40,109,97,112,40,109,97,112,32,102,114,111,109,69,110,117,109,41,36,116,97,105,108,40,115,104,111,119,32,99,41,58,112,117,114,101,32,98,41,41,34],[304,308,304,243,273,273,273,221,246,221,226,221,230,221,228,228,275,215,215,234,228,228,275,215,215,304,275,192,295,273,302,226,295,275,277,243,304,243,242,242,302,225,225,295,225,225,273,233,234,226,233,234,275,225,225,302,192,295]]

Probieren Sie es online!

Zeichensatz 1 (einschließlich Leerzeichen):

 "$()-:>E\`abcdefhilmnoprstuw×ÝáâäæéêñòóöđēĕħĮİĴ

Zeichensatz 2 (einschließlich Zeilenvorschub):

!'+,.0123456789<=@[]_qxz~

Da nur Satz 1 Nicht-ASCII-Zeichen enthält, sind ihre UTF-8-Bytes auch nicht verbunden.

Wie es funktioniert

• Programm 1 wird im Allgemeinen mit Lambda-Ausdrücken, Leerzeichen und Klammern, der freien Verwendung integrierter alphanumerischer Funktionen und den Quine-Daten als String-Literale am Ende geschrieben.

  • Der Kerncode von Programm 1 wird einfach durch Umgeben mit Anführungszeichen in Zeichenfolgenliteraldaten umgewandelt.
    • Um dies zu unterstützen, folgt jedem Backslash aoder b, die gültige Escape-Sequenzen bilden, die durchlaufen show.
    • Ein weiterer Vorteil ist , dass winzige a, bund csind die einzigen Kleinbuchstaben , deren ASCII - Codes sind weniger als 100, eine Ziffer in der numerischen Codierung von Programm 2 verwendet zu speichern.
  • Die String-Literal-Codierung des Kerncodes von Programm 2 wird durch die Verwendung von Nicht-ASCII-Unicode verschleiert: Zu jedem Zeichen wird ein Code-Punkt hinzugefügt, um sicherzustellen, dass es keine Überschneidungen mit den Originalzeichen gibt.
    • 182 war früher 128, bis mir klar wurde, dass ich die Tatsache missbrauchen könnte, dass 182 doppelt so lang ist wie das String-Literal für den Code von Programm 1, um die Dekodierung zu verkürzen. (Als Bonus kann Programm 2 Zeilenumbrüche verwenden.)

• Programm 2 wird im Allgemeinen mit Funktionsgleichungen der obersten Ebene (mit Ausnahme der letzten anonymen), Zeichenliteralen und Dezimalzahlen, Listen- / Bereichssyntax und Operatoren sowie den Quinedaten als Liste von Listen mit Ints am Ende geschrieben.

  • Der Kerncode von Programm 1 wird als Liste seiner Codepunkte mit einem abschließenden doppelten Anführungszeichen codiert.
  • Der Kerncode von Programm 2 wird als die Liste der Codepunkte des in Programm 1 verwendeten Zeichenfolgenliteral codiert, das immer noch um 182 nach oben verschoben ist.

Exemplarische Vorgehensweise, Programm 1

• bund csind die Werte der String-Literale für Programm 2 bzw. 1, die als letzte Argumente für den Lambda-Ausdruck angegeben werden. ()ist ein Scheinargument, das ausschließlich der PPCG-Regel entspricht, dass das Programm eine Funktion definieren soll.
• foldr(\a->map pred)b(show()>>c)Dekodiert die Zeichenfolge bin den Kerncode von Programm 2, indem sie map predso oft angewendet wird, wie es der Länge von show()>>c == c++coder entspricht 182.
• tail(show c)konvertiert die Zeichenfolge cin den Kerncode von Programm 1, wobei ein abschließendes Anführungszeichen angehängt wird.
• :pure bkombiniert dies in einer Liste mit der Zeichenfolge b.
• map(map fromEnum)$ konvertiert die Zeichenfolgen in Listen mit Codepunkten.
• `mappend`show(...) serialisiert die resultierende Liste der Listen und hängt sie schließlich an den Kerncode von Programm 2 an.

Exemplarische Vorgehensweise, Programm 2

• Die oberste Ebene z~z=[[['@','0'..]!!4..]!!z]ist eine Funktion, die Codepunkte zurück in Zeichen konvertiert (zum Schreiben erforderlich, da nicht alle Zeichen in toEnumverfügbar sind.)
  • Sein Codepunktargument wird auch aufgerufen z. Der Laziness-Marker ~hat in dieser Position keine Auswirkung, vermeidet jedoch ein Leerzeichen.
  • ['@','0'..] ist ein Rückwärtsschrittlistenbereich, der mit dem ASCII-Code 64 beginnt und bei jedem Schritt um 16 nach unten springt.
  • Wenn !!4man sich darauf bezieht , erhält man einen \NULCharakter.
  • Wenn Sie das in einen [ ..]Bereich einschließen, erhalten Sie eine Liste aller Zeichen, die !!zindiziert werden.
  • Das Zeichen wird schließlich in eine Singleton-Liste eingeschlossen. Dies ermöglicht das Zuordnen der Funktion züber Listen unter Verwendung =<<der nicht verfügbaren mapund <$>.
• Die oberste Ebene q[x,q]_=z=<<x++q++[34,34]++xist ein Funktionskonstruktionsprogramm 1 aus der Quinedatenliste.
  • xsind die Daten für den Kern von Programm 1 (einschließlich eines abschließenden doppelten Anführungszeichens) und die inneren qsind die verschleierten Daten für den Kern von Programm 2. _ist ein weiteres Scheinargument, das ausschließlich dazu dient, die abschließende anonyme Funktion zu einer Funktion statt nur einer Zeichenfolge zu machen.
  • x++q++[34,34]++x Verkettet die Teile, einschließlich zweier doppelter Anführungszeichen mit ASCII-Code 34.
  • z=<<Erstellt Programm 1 durch Mapping züber die Verkettung, um von Codepunkten in Zeichen zu konvertieren.
• Das Finale q[[40,...]]ist eine anonyme Funktion, die qmit den Quine-Daten kombiniert wird .

Jelly , _{128 90 87 86 85 79} 16 + 32 = 48 Bytes

“OṾ⁾ọṙŒs”OṾ⁾ọṙŒs

Probieren Sie es online!

79,7806,8318,7885,7769,338,115ỌṘ

Probieren Sie es online!

Das erste Programm führt Folgendes aus:

“OṾ⁾ọṙŒs”OṾ⁾ọṙŒs
“OṾ⁾ọṙŒs”          String literal: 'OṾ⁾ọṙŒs'
         O         ord: [79, 7806, 8318,...]
          Ṿ        Uneval. Returns '79,7806,8318,7885,7769,338,115'
           ⁾ọṙ     Two character string literal: 'ọṙ'
              Œs   Swap case the two char literal: 'ỌṘ'.

Dies belässt die Zeichenfolgen 79,7806,8318,7885,7769,338,115und ỌṘals die beiden Argumente der Kette und sie werden implizit verkettet und am Ende gedruckt.

Das zweite Programm berechnet das chr( Ọ) der Liste der zurückgegebenen Zahlen OṾ⁾ọṙŒs. Ṙdruckt “OṾ⁾ọṙŒs”(mit Anführungszeichen) und gibt die Eingabe zurück, wobei “OṾ⁾ọṙŒs”OṾ⁾ọṙŒsdie vollständige Ausgabe erhalten bleibt.

Gol> <> , _{23 + 23 = 46 22 + 22 = 44} 20 + 20 = 40 Bytes

"lF{3+|3d*HqlJJJQpp2

Probieren Sie es online!

'5ssTMMMotK-g6.6~Io

Probieren Sie es online!

Überprüfen Sie es online!

Wie sie arbeiten

"lF{3+|3d*HqlJJJQpp2

"..."        Push everything to the stack
 lF{3+|      Add 3 to everything on the stack
       3d*   Push 39 `'`
          H  Print everything on the stack (from the top) and halt

'5ssTMMMotK-g6.6~Io

'...'        Push everything to the stack
 5ss         Push 37 (34 `"` + 3)
    T    t   Loop indefinitely...
     MMMo      Decrement 3 times, pop and print
               At the end, `o` tries to print charcode -3, which is fishy (thanks Jo King)
               Program terminates

Nach Jo Kings> <> Antwort . Da es viel mehr alternative Befehle für Ausgabe und Wiederholung gab, war goder nicht erforderlich p, und die beiden Hauptkörper wurden viel kürzer.

Ein weiterer Hauptunterschied ist, dass ich die Quote des Gegners direkt oben im Stapel erzeuge. Auf diese Weise war es etwas einfacher, die Invariante von beizubehalten quote + my code + opponent code(reversed and shifted).