Wir hatten viele Herausforderungen mit Quines , aber viele der Quine-Formate sind ähnlich. Lassen Sie uns einige Unterschiede in unseren Quines erzeugen.

Ihre Aufgabe ist es, eine Auswahl von Programmen in derselben Sprache (mindestens 2) zu erstellen, die alle ihren eigenen Quellcode ausgeben. Keines dieser Programme kann jedoch Zeichen gemeinsam haben.

Zum Beispiel, wenn Sie ein Programm erstellen mit:

printf+qw(printf+qw(%s)x2)x2

Ihr nächstes Programm kann Folgendes nicht enthalten:

%()+2finpqrstwx

und so weiter.

Regeln

• Sie können Unicode-Zeichen verwenden, müssen jedoch immer noch in Bytes punkten.
• Alle Programme müssen der Community-Definition eines geeigneten Quines entsprechen . Dies bedeutet, dass der leere String unter anderem nicht als gültiger Quine zählt.
• Standardlücken sind verboten.
• Funktionen oder vollständige Programme sind zulässig, solange sie der obigen Definition entsprechen.
• Symbolunabhängige Sprachen (einschließlich Lenguage und Headsecks) sind nicht zulässig.
• Die meisten Programme gewinnen mit dem kürzesten Gesamtcode als Unentschieden.

V , 3 , 5 Quines, 46 Bytes

2A2A

Probieren Sie es online!

Hexdump:

00000000: 3241 3241                                2A2A

Erläuterung:

2     " 2 times...
 A    " (A)ppend the following text...
  2A  "   '2A'

5­­­a5­­­a

Probieren Sie es online!

Hexdump:

00000000: 35ad adad 6135 adad ad61                 5...a5...a

Erläuterung:

5---        " 5 - 3 times...
    a       " (a)ppend the following text...
     5---a  "   '5---a'

1«I1«I

Probieren Sie es online!

Hexdump:

00000000: 31ab 4931 ab49                           1.I1.I

Erläuterung:

1«      " 1 + 1 times...
  I     " (I)nsert the following text...
   1«I  "   '1«I'

Hier fangen sie an, flippig zu werden ...

ñi34x@-qPÉÑ~ÿ

Probieren Sie es online!

Hexdump:

00000000: f169 1633 341b 7840 2d71 50c9 d17e ff    .i.34.x@-qP..~.

Erläuterung:

ñ                       " Wrap all the following in macro '"q':
 i<C-v>34               "   Insert character code 34 `"`
         <esc>          "   Return to normal mode
              x         "   Delete the character we just inserted. Now, running `@-` will be equal to running `"`
                  P     "   Paste...
               @-       "   From Register...
                 q      "   "q
                   ÉÑ   "   Insert 'Ñ' at the beginning of this line
                     ~  "   Toggle the case of the character we just inserted
                      ÿ "   Black magic

:norm é:":p

Probieren Sie es online!

Hexdump:

00000000: 3a6e 6f72 6d20 e93a 223a 70              :norm .:":p

Erläuterung:

:norm       " Run the following commands as if typed:
      é:    "   insert ':'. Somehow also does black magic and resets the value of '":`
        ":p "   Paste the last ex command to be run ('norm é:":p')

Diese Antwort steckt voller schwarzer Magie. Die Quines 1 und 4 sind nicht neu, aber die anderen 3 wurden noch nie gefunden, so dass mehr als die Hälfte dieser Quines erst heute entdeckt wurde.

Jelly , _{2 3 4} 5 quines, _{14 18 81 65 59 56 326 265 247 229} 216 Bytes

3 Bytes

”ṘṘ

Probieren Sie es online!

Standard Quine. ”Ṙist das Ein-Zeichen-Literal für Ṙ. Ṙdruckt die String-Darstellung davon, dann wird der String Ṙimplizit gedruckt.

4 Bytes

⁾⁾ḤḤ

Probieren Sie es online!

⁾Beginnt ein zweistelliges Zeichenkettenliteral und Ḥverdoppelt das Argument. Wird mit einer Zeichenfolgeeingabe Ḥjedem Zeichen zugeordnet. Wenn man also Ḥauf den String einwirkt, ⁾Ḥerhält ⁾⁾ḤḤman den Quellcode.

11 Bytes

ȮṾṖƊ}“ȮṾṖƊ}

Probieren Sie es online!

Auf der rechten Seite “ȮṾṖƊ}steht das String-Literal für ȮṾṖƊ}. Das Zeichen zum Schließen der Zeichenfolge wird bei EOF stillschweigend hinzugefügt.

Auf der linken Seite des Stringliteral, ƊWraps ȮṾṖin einen einzigen Monade und }verwandelt es in eine Dyade , die sie verwendet stimmt Argument, das Stringliteral. Ȯdruckt die Zeichenfolge ( ȮṾṖƊ}), Ṿerstellt eine Zeichenfolgendarstellung der Zeichenfolge ( “ȮṾṖƊ}”) und Ṗentfernt das ”Zeichen. Die Zeichenfolge “ȮṾṖƊ}wird nach der Monade belassen und implizit gedruckt.

38 49 36 Bytes

32,52,52,7884,106,64,44,7884 44Ọj@,Ọ

Probieren Sie es online!

Zum ersten Mal habe ich einen Platz beim Jelly-Golfen benutzt.

Die Liste der Zahlen am Anfang enthält orddie restlichen Zeichen des Codes. Nachdem:

jṛ44Ọ$,Ọ
j           Join this list with...
 ṛ          right argument. Avoiding using ¤ so I can use it in the next program.
  44Ọ       chr(44)==',': [106, ',', ...]
     $      Causes Ọ to act on 44 before j acts on it.
      ,     Pair this list with...
       Ọ    chr of each number in the list. Yields jṛ44Ọ$,Ọ

270 198 180 162 Bytes

⁽¢_;⁽⁽¤;⁽¡_;⁽⁽¡;⁽¡¤;⁽$+;⁽⁽y;⁽Ẹ$;⁽⁺$;⁽AƑ;⁽?€;⁽b⁽;⁽¢¡;⁽_⁽;⁽¡¡;⁽¤ị;⁽ØJ;⁽µṭ;⁽€⁽;⁽¡S;⁽;⁽;⁽¡ʠ;⁽¤ị;⁽ØJ;⁽¤F;⁽ḊṄ;⁽ȧF
¢_⁽¤¡_⁽¡¡¤$+⁽yẸ$⁺$AƑ?€b⁽¢¡_⁽¡¡¤ịØJµṭ€⁽¡S;⁽¡ʠ¤ịØJ¤FḊṄȧF

Probieren Sie es online!

Verwendet 250er-Zahlen und -Indizes für die Jelly-Codepage. 72 Bytes durch Änderung des Algorithmus eingespart. Wurde mit Seite jede Zahl zu indizieren in Jelly Code aber jetzt ist Umwandlung der Ganzzahl zurück zur Basis 250 dann die Indizierung in Jelly Codepage, im Grunde die Anzahl der Literale Halbiert ich in der ersten Zeile muß. Dies reduziert auch die Anzahl der benötigten eindeutigen Zeichen, aber mir fällt keine Möglichkeit mehr ein, Quines zu erstellen.

Ich habe verbraucht, ⁾“”welche Zeichenfolgenliterale Ọund ØJwelche Zeichenfolgen aus Zahlen erstellen. Ich kann mir keine anderen Möglichkeiten für die Herstellung von Saiten vorstellen. Ich habe immer noch die Ziffer 9und sie ist ‘’verfügbar. Wenn es also eine andere Möglichkeit gibt, Zeichenfolgen aus Zahlen zu erstellen, ist es möglicherweise möglich, eine weitere Quine zu erstellen.

Haskell , 3 Quines, 1119 Bytes

Quine 1, 51 Bytes

Eine anonyme IOAktion, die direkt auf stdout gedruckt wird.

putStr`mappend`print`id`"putStr`mappend`print`id`"

Probieren Sie es online!

Quine 2, 265 Bytes

Die Funktion fakzeptiert ein Dummy-Argument und gibt eine Zeichenfolge zurück.

f	c=[b=<<g]!!0++show	g;b	c=[[[show	9!!0,show	1!!0..]!!6..]!!c];g=[93,0,90,52,82,89,52,51,51,94,84,24,24,39,34,34,106,95,102,110,0,94,50,89,0,90,52,82,82,82,106,95,102,110,0,48,24,24,39,35,106,95,102,110,0,40,24,24,39,37,37,84,24,24,45,37,37,84,24,24,90,84,50,94,52]

Probieren Sie es online!

Quine 3, 803 Bytes

Alles nach dem LANGUAGEPragma ist eine beliebige Funktion, die ein Dummy-Argument verwendet und einen String zurückgibt.

{-#LANGUAGE CPP#-}(\q(_:_:_:_:_:_:_:_:z)y(#)_->(y(\k x->'&':q:k:q:x)#y(\k x->'%':q:'\\':k:q:x)$y(:)#y(:)$ \x->x)z)'\''__TIME__(\(?)v k x->v$k?x)$ \(&)(%)v->v&'{'&'-'&'#'&'L'&'A'&'N'&'G'&'U'&'A'&'G'&'E'&' '&'C'&'P'&'P'&'#'&'-'&'}'&'('%'\\'&'q'&'('&'_'&':'&'_'&':'&'_'&':'&'_'&':'&'_'&':'&'_'&':'&'_'&':'&'_'&':'&'z'&')'&'y'&'('&'#'&')'&'_'&'-'&'>'&'('&'y'&'('%'\\'&'k'&' '&'x'&'-'&'>'%'\''&'&'%'\''&':'&'q'&':'&'k'&':'&'q'&':'&'x'&')'&'#'&'y'&'('%'\\'&'k'&' '&'x'&'-'&'>'%'\''&'%'%'\''&':'&'q'&':'%'\''%'\\'%'\\'%'\''&':'&'k'&':'&'q'&':'&'x'&')'&'$'&'y'&'('&':'&')'&'#'&'y'&'('&':'&')'&'$'&' '%'\\'&'x'&'-'&'>'&'x'&')'&'z'&')'%'\''%'\\'%'\''%'\''&'_'&'_'&'T'&'I'&'M'&'E'&'_'&'_'&'('%'\\'&'('&'?'&')'&'v'&' '&'k'&' '&'x'&'-'&'>'&'v'&'$'&'k'&'?'&'x'&')'&'$'&' '%'\\'&'('&'&'&')'&'('&'%'&')'&'v'&'-'&'>'&'v'

Probieren Sie es online!

Zeichen

Quine 1:

"S`adeimnprtu

Quine 2:

	!+,.0123456789;<=[]bcfghosw

Quine 3:

 #$%&'()-:>?ACEGILMNPTU\_kqvxyz{}

Wie es funktioniert

Quine 1

putStr`mappend`print`id`"putStr`mappend`print`id`"

Quine 1 ist eine modifizierte Version meines Golfs. Sie ist eine quine Antwort (mit Verbesserungen von H.PWiz):

• Da volle Programme nicht benötigt werden, main=wurde entfernt.
• <>und $wurden durch ihre Beinahe-Synonyme mappendund ersetzt id.

Dies macht die lebenswichtigen Charaktere =<>und den hilfreichen Operator $für die anderen Quines frei.

Quine 2

f	c=[b=<<g]!!0++show	g;b	c=[[[show	9!!0,show	1!!0..]!!6..]!!c];g=[93,0,......]

Quine 2 verwendet ähnliche Methoden wie das Programm 2 meiner kürzlich erschienenen Antwort " Gegenseitig ausschließende Quines" , ist jedoch angepasst, um sich selbst direkt zu quinen und insbesondere die Verwendung von Zeichenliteralen zu vermeiden, die für Quine 3 benötigt werden. Beides wird mit Hilfe der showFunktion erreicht. was zum Glück noch keinen seiner Charaktere verwendet hat.

Diese Quine verwendet Tabulatoren anstelle von Leerzeichen, aber ich habe Leerzeichen zur besseren Lesbarkeit verwendet.

• gist die Quine-Daten als eine Liste von ganzen Zahlen am Ende des Codes. Jede Zahl steht für ein Zeichen aus dem Rest des Codes.
  • Die Nummern werden um verschoben 9, so dass die Registerkarte ist 0. Dadurch wird die Codierung etwas kürzer, da die Kleinbuchstaben für die Funktions- und Variablennamen zweistellig sind.
• b c=[[[show 9!!0,show 1!!0..]!!6..]!!c] ist eine Funktion, um eine Zahl in ein Zeichen umzuwandeln (eigentlich eine Zeichenkette aus einem Zeichen).
  • [[show 9!!0,show 1!!0..]!!6..]ist ein Zeichenbereich, der mit einem Tabulatorzeichen beginnt, das mit indiziert wird !!c.
  • Das Tabulatorzeichen selbst wird durch Indizieren in einen anderen Bereich erzeugt [show 9!!0,show 1!!0..], wobei mit den Ziffern begonnen wird '9'und '1'in Schritten von 8 nach unten gesprungen wird.
  • Die Ziffernzeichen werden durch Indizieren in die showZeichenfolge der entsprechenden Ziffer erzeugt.
• f c=[b=<<g]!!0++show gist die Hauptfunktion. cist ein Scheinargument.
  • b=<<gverwendet =<<, um jede Zahl in gihr Zeichen umzuwandeln . (Die Verwendung von =<<anstelle von z. B. mapist, warum bdas zurückgegebene Zeichen in eine Liste eingeschlossen werden muss.)
  • show gGibt die Zeichenfolgendarstellung der gListe von an und ++verkettet die Zeichenfolgen.
  • Da es =<<eine niedrigere Priorität als hat ++, ist eine gewisse Belichtungsreihe erforderlich. Indiziert eine Liste mit einem Element, um die Verwendung von ()(für Quine 3 reserviert) zu vermeiden [...]!!0.

Quine 3

Aufgrund des Designs der anderen Quines hat Quine 3 weiterhin Zugriff auf Klammern, Lambda-Ausdrücke, Zeichenliterale und den String / List-Konstruktor :. Dies reicht aus, um eine Funktion zu erstellen, die den Code der Quine einer Zeichenfolge voranstellt .

Leider wurden alle Vokale in Kleinbuchstaben (außer manchmal y) verwendet, sodass keine nützlichen alphanumerischen Funktionen vorhanden waren. Auch []""sind verschwunden. Diese Blätter keine normale Art und Weise eine leere Zeichenfolge zu bauen zu beginnen vorgibt , um den Code zu.

Fast alle Großbuchstaben sind jedoch noch verfügbar, sodass ein LANGUAGEPragma für eine Spracherweiterung möglich ist. Auch hier ist CPP(enable C preprocessor) die einzige Spracherweiterung, die nur mit Großbuchstaben benannt wird. CPP-Makros haben häufig Namen in Großbuchstaben.

Um den wesentlichen leeren String zu erhalten, aktiviert das quine CPP, verwendet das __TIME__Makro, um eine String-Konstante des Formulars zu erhalten "??:??:??"(die bequemerweise garantiert immer die gleiche Länge hat) und Musterübereinstimmungen darauf.

{-#LANGUAGE CPP#-}(\q(_:_:_:_:_:_:_:_:z)y(#)_->(y(\k x->'&':q:k:q:x)#y(\k x->'%':q:'\\':k:q:x)$y(:)#y(:)$ \x->x)z)'\''__TIME__(\(?)v k x->v$k?x)$ \(&)(%)v->v&'{'&'-'&......

Nach dem Sprach-Pragma besteht das Quine aus einem Lambda-Ausdruck, der seine Parameter an diese vier Argumente bindet (wobei ein letzter Dummy-Parameter _für die spätere Anwendung übrig bleibt ):

• qgebunden an '\'', ein einfaches Anführungszeichen gebend;
• _:_:_:_:_:_:_:_:zgebunden an __TIME__, auch bekannt als eine Zeichenkette "??:??:??", wodurch zeine leere Zeichenkette entsteht;
• ygebunden an (\(?)v k x->v$k?x)einen Lambda-Kombinator, der verwendet wird, um das Konvertieren der Quine-Daten von der links zugeordneten ("foldl") in die rechts zugeordnete ("foldr") Form zu unterstützen;
• Der Bediener ist daran (#)gebunden \(&)(%)v->v&'{'&'-'&..., die Daten quine selbst.

Die Quine-Daten werden in Form einer Church-Codierung angegeben, einem Lambda-Ausdruck mit Parametern (&)(%)v.

• Durch Anwenden des Ausdrucks auf bestimmte Werte zu instanziieren (&), (%)und vkann diese Codierung entweder verwendet werden , um den Kerncode des quine zu bauen oder die Datendarstellung quine selbst umzubauen.
• Nach Haskells Standard-Fixitätsregel werden &und %assoziative Operatoren im Lambda belassen. Somit werden die Zeichenparameter mit dem Anfangsbuchstaben vvon links beginnend kombiniert .
• Für die meisten Zeichen kgibt es eine entsprechende &'k'.
• Wenn kist 'oder \, die innerhalb Zeichenliterale werden müssen entkommen, ist die Codierung statt %'\k'.

Da die Datencodierung linksassoziativ ist, Zeichenfolgen jedoch rechtsassoziativ aufgebaut sind, wird der Kombinator y = (\(?)v k x->v$k?x)eingeführt, um die Nichtübereinstimmung zu überbrücken.

• y(...)soll geeignete Funktionen für die Verwendung als Quine-Daten (&)und (%)Operatoren erstellen .
• vist eine Funktion von Zeichenkette zu Zeichenkette (die beabsichtigten vQuinedaten sind Beispiele).
• kist ein Zeichen, xeine Zeichenfolge und ?ein Operator, der sie zu einer neuen Zeichenfolge kombiniert. (Für den Kerncode (?)=(:). Um die quine-Datendarstellung tatsächlich zu rekonstruieren, ist es komplizierter.)
• So y(?)v k = \x->v$k?xist eine andere Funktion von Zeichenketten zu Zeichenketten.

• Als Beispiel dafür, wie dies die Assoziativität ändert, wenn (&)=y(:):

  (v&k1&k2&k3) x
  = (((v&k1)&k2)&k3) x
  = y(:)(y(:)(y(:)v k1)k2)k3 x
  = y(:)(y(:)v k1)k2 (k3:x)
  = y(:)v k1 (k2:(k3:x))
  = v (k1:(k2:(k3:x)))
  = v (k1:k2:k3:x)

Im Allgemeinen gilt: Wann (#)ist die Quine-Datenfunktion und wann f1,f2sind Funktionen, die Zeichen mit Zeichenfolgen kombinieren:

(y(f1)#y(f2)$v) x
= (...(y(f1)(y(f1)v '{') '-')...) x
= v(f1 '{' (f1 '-' (... x)))

Anwenden der Quine-Datenfunktion mit (&)=y(f1)und (%)=y(f2), und dies verwendet die vorgeschriebenen f1und f2, um die Zeichen der Quine-Daten mit zu kombinieren x, und übergibt dann den resultierenden String an v.

Der Hauptteil des Lambda-Ausdrucks fügt dies zusammen:

(y(\k x->'&':q:k:q:x)#y(\k x->'%':q:'\\':k:q:x)$y(:)#y(:)$ \x->x)z

• '&':q:k:q:xEin Zeichen kwird &'k'der Zeichenfolge vorangestellt x, während die ursprünglichen Quine-Datenformen '%':q:'\\':k:q:xvorangestellt %'\k'werden.
• Somit y(\k x->'&':q:k:q:x)#y(\k x->'%':q:'\\':k:q:xsind die richtigen Parameter für die Neuerstellung der Quine-Datendarstellung vorhanden, die dem final z(der leeren Zeichenfolge) vorangestellt und dann an die folgende Funktion übergeben werden.
• y(:)#y(:) sind die richtigen Parameter, um den Kerncode des Quines ohne weitere Modifikation einem String voran zu stellen.
• Schließlich wird das \x->xbekommt nichts mit dem konstruierten quine zu tun, die zurückgegeben wird.

Perl 6 , 3 Quines, 274 Bytes

Quine 1, 52 Bytes

my&d={S{\d}=$_};say
d
Q{my&d={S{\d}=$_};say
d
Q{4}}

Probieren Sie es online!

Quine 2, 102 Bytes

printf	|(q[printf	|(q[@]xx	2	Z~|(q[printf	|(q[!3]]Xx	qw[1	0]))]xx	2	Z~|(q[printf	|(q[!3]]Xx	qw[1	0]))

Probieren Sie es online!

Quine 3, 120 Bytes

<'.EVAL'.UC,' GIVEN ',｢｢PRINT "<'.EVAL'.UC,' GIVEN ',｢｢".UC,.UC,"｣｣>.LC",".EVAL.EVAL".UC｣｣>.lc.EVAL.EVAL

Probieren Sie es online!

Überprüfung verschiedener Bytesätze

Es war viel zu manövrieren, diese dritte Quine zu bekommen. 6 Perl verfügt über 4 Methoden der Ausgabe (das ich kenne), say, put, printund printf. Beide sayund putAusgabe von Zeilenumbrüchen, da ich nicht beide verwenden kann. put, print, printfAlle enthalten pund t. Wir können dies teilweise umgehen, indem wir EVALGroßbuchstaben verwenden PRINT. Von dort aus glaube ich nicht, dass es möglich ist, 4 Quines zu bekommen ... (obwohl vielleicht so etwas klappen shell "echo 'quine'"könnte)

Wir können dann Abstandsprobleme umgehen, indem wir verschiedene Arten von Leerzeichen verwenden, um Operatoren, Leerzeichen, Tabulatoren und Zeilenumbrüche zu trennen.

Erklärungen:

Quine 1:

my&d={        };         # Declare a function d which 
      S{\d}=$_           # Which substitutes a digit with the string again
                say      # Print with a newline
d                        # The function
Q{my&d={S{\d}=$_};say    # Applied to the string with the program
d
Q{4}}                    # With a digit where the it should be inserted again

Quine 2:

Dies ist ein Quine im Format printf |(q[printf q[%s]]xx 2), dh es formatiert eine Kopie des Strings in sich. Wir können es jedoch nicht verwenden, sda es in der vorherigen Quine verwendet wurde say. Also benutzen wir den String OR-Operator ( ~|) für @und !3, um den %sTeil zu produzieren , aber wir können das nicht sowohl für den Format-String als auch für den einzufügenden String tun, also haben wir es Z~mit dem Extra-String und einem leeren String zu tun. obwohl wir dann nicht verwenden können ,, um die beiden zu trennen, müssen wir dann Xx qw[1 0]mit 1 und 0 multiplizieren.

printf |(                                  )      # Print with formatting
         q[...]       # The string of the program
               xx 2   # Duplicated
                    Z~| (                 )     # String or'd with
                         q[...]                 # A copy to insert the %s
                                Xx              # String multiplied to
                                   qw[1 0]      # itself and an empty string

Quine 3:

Dies ist ein EVAL-Quine, der sein Bestes tut, um Konflikte mit den anderen Quines zu vermeiden. Dies beinhaltet eine Menge von EVALs sowie eine ganze Reihe von lcund uczwischen Fällen zu konvertieren.

<...>.lc.EVAL        # Evaluate the lowercase version of the string which results in
.EVAL  given  ｢print "<'.eval'.uc,' given ',｢｢".uc,.uc,"｣｣>.lc",".eval.eval".uc｣
             .EVAL   # Evaluate again 

.EVAL  given  ｢...｣   # Set the string to $_ and pass it to .EVAL
print "<'.eval'.uc,' given ',｢｢".uc       # Print the first half of the quine uppercased
                                   ,.uc   # Print the string uppercased
                                       ,"｣｣>.lc"  # Print the .lc part lowercased
                                                ,".eval.eval".uc # Print the EVAL part uppercased

MathGolf , 4 5 6 Quines, 193.535 Bytes

9 Bytes

ÿ'ÿ⌐_'ÿ⌐_

Probieren Sie es online!

45 Bytes

û]∙ûxôû¬ûûûûû╡¬ûô╡û╡xûxxû¬ô]∙xô¬ûûû╡¬ô╡╡xxx¬ô

Probieren Sie es online!

49 Bytes

ùa6æù\a\ù+6┼ù\ùùùùù\ù§\+ùΣ\Σa6æ\a\+6┼\ùùùù\§\+Σ\Σ

Probieren Sie es online!

99 Bytes

"""▐ ⌠▌ ⌠▌ ⌠▌ ⌠ ⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠ ⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠"`~

Probieren Sie es online!

4488 Bytes

♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠(((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠(((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠(((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((♠((((((((((((((((((((((((((((((((((((((((((((DÄß─·ö♠,♦M-$*DÄß─ö7($$$qq$Äq╘

Probieren Sie es online!

188.845 Bytes

Ich kann nicht wirklich auf dieses Programm verlinken, daher hier ein Perl 6-Programm, das das eigentliche Quine generiert

Überprüfung der Unterscheidbarkeit

Ich kann definitiv eine weitere Quine daraus pressen, obwohl ich glaube, dass ich keine Möglichkeit mehr habe, Strings direkt auf den Stack zu schieben, sodass ich auf fremde Methoden zurückgreifen muss. Noch seltsamere Methoden kommen auf mich zu, als ich mich um eine sechste Quine bemühe. In einigen Fällen könnten die Quines kürzer sein, aber ich reduziere die in Vorbereitung verwendeten Bytes.

Okay, ich könnte technisch in der Lage sein, noch eine Quine zu machen, da ich noch ein paar Operatoren habe (Push-String, Inkrement-String, Duplizieren, Mappen, Poppen), ist es die Schleife, die uns einschränkt. Dies {}sind die einzigen Operatoren, die einen Codeblock beliebiger Länge angeben können, und ich brauche sie wirklich im sechsten Quine. Ich könnte einige der anderen Codeblöcke verwenden, aber sie sind begrenzt, und ich bezweifle, dass die Schleifenabschnitte so kurz sein werden, da uns die einfachen Operatoren ausgehen.

Okay, einige verspätete Erklärungen:

Alle Quines haben fast die gleiche Struktur:

• Schieben Sie eine Zeichenfolge oder eine Liste von Zeichenfolgen oder eine Liste von Zeichen in den Stapel.
• Kombinieren Sie alles in einer Liste
• Duplizieren Sie die Liste
• Mappe über die Kopie und drucke / drücke die Zeichen, um die Originalzeichen zu erhalten
• Drucken Sie die ursprüngliche Liste der Zeichen als Zeichenfolge

Quine 1:

Dies ist im Grunde das Gleiche wie das, was ich in der normalen Quine-Frage gepostet habe.

ÿ'ÿ⌐_'ÿ⌐_
ÿ            Push the next 4 bytes as a string
 'ÿ⌐_        Stack ["'ÿ⌐_"]
     'ÿ      Push the byte ÿ (I realise I could have used this in a later quine)
       ⌐     Rotate the ÿ to the bottom of the stack : ["ÿ", "'ÿ⌐_"]
        _    Duplicate top of stack: ["ÿ", "'ÿ⌐_", "'ÿ⌐_"]
             Implicitly print stack joined together : ÿ'ÿ⌐_'ÿ⌐_

Quine 2

û                Push the next 2 bytes as a string
 ]∙              Stack: ["]∙û"]
   û  û...      Repeat this for the rest of the code
           ]              Wrap the stack in an array : [["]∙","xô"...]]
            ∙             Triplicate                 : [[..],[..],[..]]
             x            Reverse the top array
              ô           Loop over the array, executing the next 6 instructions
                          Stack: [[..],[..],str]
               ¬          Rotate the stack : [str,[..],[..]]
                ûûû╡      Push the string "ûû" and discard the left character
                    ¬     Rotate the "û" to the bottom : ["û",str,[..],[..]]
                          This produces the initialisation part
                     ô    Loop over the array with the next 6 characters again
                      ╡╡xxx¬      Basically discard the string
                            ô     Flatten the last copy of the array onto the stack
                                  Implicitly output the code

Quine 3:

ùa6æù\a\ù+6┼ù\ùùùùù\ù§\+ùΣ\Σa6æ\a\+6┼\ùùùù\§\+Σ\Σ
ù...          Push the next 3 bytes as a string
              You know how this goes
    a         Wrap the top element in an array
     6æ       Repeat the next 4 instructions 6 times
       \      Swap the two top items
        a     Wrap the top item in an array
         \    Swap back
          +   Combine the two arrays
              This puts all the strings into a single array
           6            Push a 6
            ┼           Push the element two items down (the array)
             \          Swap with the 6 (this basically duplicates the array)
              ùùùù      Push "ùùù"
                  \§    Swap and get the 6th character (wrapping)
                    \   Swap with array : ["ù", [..]]
                     +  Prepend to array (implicitly mapping)
                      Σ\Σ     Join both the lists to strings and output

Quine 4:

"""▐ ⌠▌ ⌠▌ ⌠▌ ⌠ ⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠ ⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠⌠"`~
""             Push the empty string
  "..."        Push some code : ['','...']
       `       Copy the top two elements of the stack : ['','...','','...']
        ~      Evaluate the top element as code : ['','...','']
▐              Prepend the empty string to the code
  ⌠            Push a space and increment by 2 to get a quote
   ▌           Prepend to the array
     ⌠▌ ⌠▌ ⌠   Repeat three more times, leaving the last on top : ['', '""...','"']
              ⌠⌠...       Push a space and increment until it reaches a '`'
                    ⌠⌠... Repeat for the '~' : ['','"""...','"','`','~']
                          Implicitly output

Quine 5:

♠              Push 256
 ((...         Decrement until it reaches the correct byte representing the code
               Repeat for each character of the code
      DÄ       Repeat the next instruction 14 times
        ß      Wrap the top 4 elements in an array
         ─     Flatten the resulting monstrosity
          ·    Triplicate the array
           ö   Map the next 7 instructions over the array
                      Stack : [[..],[..],num]
            ♠         Push 128
             ,        Reverse subtraction : [[..],[..],128-num
              ♦M-$    Push the ( character
                  *   Repeat it 128-num times
                   DÄß─         Gather that up in an array and flatten again
                       ö        Map the next 6 instructions
                        7($$$qq
                    7($$$q    Print a ♠, without newline
                              q   Print the brackets without newline
                                  Stack : [[..],[..]]
                               $     Map the number to their values in the code page
                                Äq   Map print over each element
                                  ╘  Discard the last element of the stack

Quine 6:

Der Grund, warum dieses Quine so viel länger ist als die anderen, ist, dass beim Inkrementieren von Strings Unicode-Darstellungen verwendet werden, was für einige der Zeichen im Code wirklich schade ist, besonders wenn wir versuchen, das Zeichen ⌂im Code zu erstellen, das den Code aufbläht um über 8000 Zeichen, die dann den Darstellungsteil um einen sehr großen Betrag aufblasen.

⌂         Push an * character
 ))...    Increment until we reach the right character + 8
      ♫{ }            Repeat 10000 times
        α             Wrap the top two elements in an array
          ♫{     }    Then repeat 10000 times
            m{{}}     Shallowly flatten the array
                  h∞<     Double the array
                     m{          Map the doubled array to
                       ïí½<¿{    If it is the first half of the array
                             ⌂⌂  Push two asterisks
                               )))...    Increment into a '⌂' (there are something like 8000 )s here, with a couple of ! to help
                                     @   Rotate the top three elements
                                         Stack : ["⌂",char,"*"]
                                      0{     α4<{}=}←  Repeat while the asterisk is not the char
                                        ⌂⌡)   Push a )
                                           @  Rotate it under the char
                                            ) Increment the asterisk
                                                     ;;   Pop the extra copies of the character
                                                       }{  Else
                                                         ⌡⌡⌡⌡}   Subtract 8 from the character
                                                              }{}  End map and flatten array
                                                                   Print implicitly

Dieses letzte Quine würde erheblich reduziert, wenn MathGolf konsistent wäre, ob Zeichenfolgen die native Codepage verwenden oder nicht.

Python 2, 2 Quines, 434 353 349 446 Bytes

Dies war meistens nur, um zu sehen, ob ich es in Python schaffen konnte.

30 Bytes (einschließlich einer nachgestellten Newline):

z='z=%r;print z%%z';print z%z

und 416 Bytes ohne nachfolgende Newline:

exec"696d706f7274207379730a793d222222696d706f7274207379730a793d7b7d0a7379732e7374646f75742e777269746528276578656322272b792e666f726d6174282722272a332b792b2722272a33292e656e636f6465282268657822292b27222e6465636f64652822686578222927292222220a7379732e7374646f75742e777269746528276578656322272b792e666f726d6174282722272a332b792b2722272a33292e656e636f6465282268657822292b27222e6465636f6465282268657822292729".decode("hex")

(Ich habe dank Lynn 81 Bytes Golf gespielt, aber eine Ladung hinzugefügt, weil ich mich um die Newline gekümmert habe.)

Erläuterung

Das erste ist nur das Standard- Short-Python-Quine , wurde jedoch so modifiziert, dass es nicht verwendet werden kann _. Da dies Python 2 ist, wird auch (oder nicht verwendet ).

Der zweite dachte nach. Die lange Zeichenfolge wird mit dem hexCodec codiert (wodurch sichergestellt wird, dass sie nur 0- 9und a- enthält f) und als decodiert

import sys
y="""import sys
y={}
sys.stdout.write('exec"'+y.format('"'*3+y+'"'*3).encode("hex")+'".decode("hex")')"""
sys.stdout.write('exec"'+y.format('"'*3+y+'"'*3).encode("hex")+'".decode("hex")')

Diese nutzt quine Tricks seinen eigenen Quellcode zu erhalten, dann codiert sie mit hex_codec, und dann druckt er umgeben von exec"".decode("hex"), mit sys.stdout.writeDruck ein Newline zu vermeiden. Wenn Sie diesen Code ausführen, wird das zweite Quine ausgegeben. So habe ich es generiert.

Ich vermute, dass mehr als zwei in Python unmöglich sind, obwohl ich es gerne sehen würde, wenn ich mich irre!

Wenn es Ihnen nichts ausmacht, Quines auszuwerten

Ørjan Johansen schlug für die vorkodierte zweite Quine Folgendes vor

y="""import sys
sys.stdout.write('exec"'+('y='+'"'*3+y+'"'*3+';exec y').encode("hex")+'".decode("hex")')""";exec y

Dies würde 30 + 248 = 278 Bytes für die folgende Ausgabe ergeben:

exec"793d222222696d706f7274207379730a7379732e7374646f75742e777269746528276578656322272b2827793d272b2722272a332b792b2722272a332b273b65786563207927292e656e636f6465282268657822292b27222e6465636f64652822686578222927292222223b657865632079".decode("hex")

Die Verwendung von execauf diese Weise ist kein Schummeln gemäß den PPCG- Regeln, aber es fühlt sich für mich etwas schummelhaft an (elegant und clever, aber immer noch schummelhaft), weil einige Zeichen sowohl als Code als auch als Daten verwendet werden. (Obwohl meine Version verwendet wird exec, sind der Code und die Daten getrennt.) Also werde ich meine Punktzahl bei 446 halten.

Japt , 2 3 Quines, 106 172 Bytes

Die erste ist eine ziemlich ausführliche Version meiner N char quine Antwort .

[91,57,49,100,185,44,85,44,186,57,51,100,185,44,186,49,48,100,185,44,186,85,109,100,185,172,93,172]
[91d¹,U,º93d¹,º10d¹,ºUmd¹¬]¬

Probieren Sie es hier aus .

Die zweite Quine ist die bessere Quine von ETHProduction , eine gute Standard-Quine für Japt.

"iQ ²"iQ ²

Probieren Sie es hier aus .

Der dritte verwendet ``und Char-Code-XORing, um die Daten zu speichern.

T=`f=fR;Zff-R-ReX%`;`T=\``+T+Tc^#

Probieren Sie es hier aus .

Da ()'es noch verfügbar ist, könnte es möglich sein, noch eine Quine herauszudrücken.

Gol> <> , ₂ 3 Quines, _{17 28 27} 26 Bytes

6 Bytes

"r2ssH

Probieren Sie es online!

_{11 10} 9 Bytes

'3d*Wo{|;

Probieren Sie es online!

11 Bytes

Eh`#Ma0piS0

Probieren Sie es online!

Gol> <> hat drei Möglichkeiten, Zeichen zu drucken:

• o Geben Sie einen Wert ein und drucken Sie ihn als Zeichen
• H Pop alles, drucke als Zeichen und halte an
• S"..." Gibt ein String-Literal aus, ohne den Stack zu beeinflussen

Da ich jedoch keine Möglichkeit gefunden habe, einen Quine mit S"..."der einzigen Ausgabemethode zu schreiben , habe ich mir die beiden oben genannten Methoden ausgedacht und die beiden Arten von String-Literalen verwendet.

Die dritte (von Jo King) verwendet den pBefehl, um das "In S"on the Fly zu erstellen , das am Ende alles außer der Null ausgibt. Dann Ehdruckt die Null und beendet.

Nachdem wir nun alle Ausgabebefehle UND den pBefehl aufgebraucht haben , glaube ich, dass es unmöglich ist, ein weiteres Quine zu erstellen (es sei denn, jemand kommt mit dem S"Quine ohne p).

Ruby , 2 Quines, 27 + 44 = 71 Bytes

$><<<<2*2<<2
$><<<<2*2<<2
2

Probieren Sie es online!

s=%q{s=%q{S};s[?S]=s;puts s};s[?S]=s;puts s

Probieren Sie es online!

Ich bin hier hauptsächlich durch Ausgabemethoden eingeschränkt. Es gibt einige Möglichkeiten, Zeichenfolgen zu manipulieren, aber abgesehen von $><<all den verwendbaren Ausgabemethoden scheint es zu viele Überschneidungen zu geben. Ich denke, es könnte einen Ausweg geben, evalaber es ist schwierig, mehrere Zeichenfolgenmanipulationen unterschiedlicher Art zu verschachteln.

Javascript ES6, 2 Quines, 43 + 22 = 65 Bytes

Quine 1:

(function f(){return[,f,'))'].join('(')}())

Quine 2:

g=z=>"g="+g+";g``";g``

> <> , 2 Quines, 8 + 16 = 24 Bytes

8 Bytes

#o<}-1:"

Probieren Sie es online!

Aus dieser Antwort entnommen .

16 Bytes

'r3d*d8*7+e0p>>|

Probieren Sie es online!

Dies basiert auf der 'r3d*>o<quine, mit der Ausnahme ound <nicht verwendet werden kann, so ersetzt I <mit |und dynamisch erstellt o(111 = 8 * 13 + 7) , und es dort platziert , wo die 2. >ist.

2 Quines ist die Grenze

Leider sind wir durch die Anzahl der Ausgabebefehle begrenzt. nist nicht sinnvoll, da es nur Zahlen ausgibt und daher oin jedem Quine ausgeführt werden muss. Die einzige Möglichkeit, dynamisch zu erstellen, oist mit p. Ein Quine kann also verwendet owerden und ein anderer kann es mit erstellen p, aber es kann kein drittes Quine geben.

Es könnte möglich sein, dass eine dritte Quine den Quellcode auf dem Stack belässt, wenn dies zählt.

Java 10, 2 Quines, 1448 - 1248 Byte

1350 1122 Bytes

\u0076\u002D\u003E\u007B\u0076\u0061\u0072\u0020\u0072\u003D\u0022\u0076\u002D\u003E\u007B\u0076\u0061\u0072\u0020\u0072\u003D\u0025\u0063\u0025\u0073\u0025\u0031\u0024\u0063\u003B\u0072\u002E\u0066\u006F\u0072\u006D\u0061\u0074\u0028\u0072\u002C\u0033\u0034\u002C\u0072\u002C\u0039\u0032\u0029\u002E\u0063\u0068\u0061\u0072\u0073\u0028\u0029\u002E\u0066\u006F\u0072\u0045\u0061\u0063\u0068\u0028\u0063\u002D\u003E\u0053\u0079\u0073\u0074\u0065\u006D\u002E\u006F\u0075\u0074\u002E\u0070\u0072\u0069\u006E\u0074\u0066\u0028\u0025\u0031\u0024\u0063\u0025\u0063\u0025\u0033\u0024\u0063\u0075\u0025\u0025\u0030\u0034\u0058\u0025\u0031\u0024\u0063\u002C\u0063\u0029\u0029\u003B\u007D\u0022\u003B\u0072\u002E\u0066\u006F\u0072\u006D\u0061\u0074\u0028\u0072\u002C\u0033\u0034\u002C\u0072\u002C\u0039\u0032\u0029\u002E\u0063\u0068\u0061\u0072\u0073\u0028\u0029\u002E\u0066\u006F\u0072\u0045\u0061\u0063\u0068\u0028\u0063\u002D\u003E\u0053\u0079\u0073\u0074\u0065\u006D\u002E\u006F\u0075\u0074\u002E\u0070\u0072\u0069\u006E\u0074\u0066\u0028\u0022\u005C\u005C\u0075\u0025\u0030\u0034\u0058\u0022\u002C\u0063\u0029\u0029\u003B\u007D

Probieren Sie es online aus.

Gleichwertig:

v->{var r="v->{var r=%c%s%1$c;r.format(r,34,r,92).chars().forEach(c->System.out.printf(%1$c%c%3$cu%%04X%1$c,c));}";r.format(r,34,r,92).chars().forEach(c->System.out.printf("\\u%04X",c));}

Erläuterung:

v->{                   // Method with empty unused parameter and no return-type
  var r="v->{var r=%c%s%1$c;r.format(r,34,r,92).chars().forEach(c->System.out.printf(%1$c%c%3$cu%%04X%1$c,c));}";
                       //  Unformatted source code
  r.format(r,34,r,92)  //  Formatted quine
   .chars()            //  Loop over the characters as integers
   .forEach(c->System.out.printf("\\u%04X",c));}
                       //   Print "\u" with hexadecimal value of these characters

126 Bytes

v->{int i='}'-'[';var s="v->{int i='}'-'[';var s=%c%s%c;System.console().printf(s,i,s,i);}";System.console().printf(s,i,s,i);}

System.console()wird zurückgegeben, nullwenn keine angegeben ist, daher gibt TIO NullPointerExceptionin diesem Fall a zurück .

Um zu beweisen , es ist ein Arbeits quine, ersetzen System.console()mit System.out: Versuchen Sie es online.

Erläuterung:

v->{              // Method with empty unused parameter and no return-type
  int i='}'-'[';  //  Integer `i` = 34 (unicode value for double-quote)
  var s="v->{int i='}'-'[';var s=%c%s%c;System.console().printf(s,i,s,i);}";
                  //  Unformatted source code
  System.console().printf(s,i,s,i);}
                  //  Print formatted quine

Allgemeine Erklärung:

In Java läuft eine Quine normalerweise so ab:

• Das String senthält den unformatierten Quellcode.
• %swird verwendet, um diesen String in sich selbst mit dem einzugeben s.format(...).
• %c, %1$cUnd die 34werden verwendet , um die doppelten Anführungszeichen zu formatieren.
• s.format(s,34,s) setzt alles zusammen.

In diesem Fall wäre die kürzeste Lambda-Funktion in Java 10 die folgende ( 82 Byte ):

v->{var s="v->{var s=%c%s%1$c;return s.format(s,34,s);}";return s.format(s,34,s);}

Probieren Sie es online aus.

Da die einzige Möglichkeit, zwei Quines in Java zu haben, darin besteht, die Unicode-Version mit zu verwenden \uHEXA, die beim Kompilieren in Zeichen umgewandelt wird, kann ich die Zeichen 0123456789ABCDEF\uin der Nicht-Unicode-Version nicht verwenden. Daher wird die kleinere Nicht-Unicode-Version System.console()anstelle von returnoder System.out(beide mit einem 'u') '}'-'['und zweimal und %canstelle von 34und verwendet %1$c.

Einige Dinge, die Sie über die Unicode-Version beachten sollten:

• Ich verwende absichtlich %04Xanstelle von %04x(für Hexadezimal-Großbuchstaben anstelle von Kleinbuchstaben).
• Ich verwende 92, %cund %3$cdie Schrägstriche zu formatieren.
• Die Verwendung von Großbuchstaben \Uanstelle von Kleinbuchstaben \uist anscheinend nicht zulässig, da ich sonst nur returndie kürzere Nicht-Unicode-Version verwendet hätte.