Nous avons eu beaucoup de défis de quine , mais beaucoup de formats de quine sont similaires, permet de créer une certaine variance dans nos quines.

Votre tâche consiste à créer une sélection de programmes dans la même langue (au moins 2), qui produisent tous leur propre code source, cependant, aucun de ces programmes ne peut partager de caractères.

Par exemple, si vous créez un programme en utilisant:

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

Votre prochain programme ne peut comprendre aucun des éléments suivants:

%()+2finpqrstwx

etc.

Règles

• Vous pouvez utiliser des caractères Unicode, mais vous devez toujours marquer en octets.
• Tous les programmes doivent répondre à la définition communautaire d'un quine approprié . Cela signifie que la chaîne vide ne compte pas entre autres comme un quine valide.
• Les failles standard sont interdites.
• Les fonctions ou les programmes complets sont autorisés tant qu'ils répondent à la définition ci-dessus.
• Les langues indépendantes des symboles (y compris le Lenguage et les Headsecks) sont interdites.
• La plupart des programmes gagnent, avec le code total le plus court comme briseur d'égalité.

V , 3 , 5 quines, 46 octets

2A2A

Essayez-le en ligne!

Hexdump:

00000000: 3241 3241                                2A2A

Explication:

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

5­­­a5­­­a

Essayez-le en ligne!

Hexdump:

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

Explication:

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

1«I1«I

Essayez-le en ligne!

Hexdump:

00000000: 31ab 4931 ab49                           1.I1.I

Explication:

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

Voici où ils commencent à devenir funky ...

ñi34x@-qPÉÑ~ÿ

Essayez-le en ligne!

Hexdump:

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

Explication:

ñ                       " 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

Essayez-le en ligne!

Hexdump:

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

Explication:

: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')

Cette réponse est remplie de magie noire. Les quines 1 et 4 ne sont pas nouvelles, mais les 3 autres n'ont jamais été trouvées auparavant, donc plus de la moitié de ces quines viennent d'être découvertes aujourd'hui.

Gelée , _{2 3 4} 5 quines, _{14 18 81 65 59} 56326 _{265 247 229} 216 octets

3 octets

”ṘṘ

Essayez-le en ligne!

Quine standard. ”Ṙest le seul caractère littéral pour Ṙ. Ṙaffiche la représentation sous forme de chaîne de ceci, puis la chaîne est Ṙimplicitement imprimée.

4 octets

⁾⁾ḤḤ

Essayez-le en ligne!

⁾commence un littéral de chaîne de deux caractères et Ḥdouble son argument. Avec une entrée de chaîne, Ḥest mappé sur chaque caractère. ḤAgissant ainsi sur la chaîne ⁾Ḥdonne ⁾⁾ḤḤ, le code source.

11 octets

ȮṾṖƊ}“ȮṾṖƊ}

Essayez-le en ligne!

Sur le côté droit, “ȮṾṖƊ}est le littéral de chaîne pour ȮṾṖƊ}. Le caractère de fermeture de chaîne est tacitement ajouté à l'EOF.

À gauche du littéral de chaîne, Ɗs'enroule ȮṾṖen une seule monade et la }transforme en dyade qui utilise son argument de droite, le littéral de chaîne. Ȯimprime la chaîne ( ȮṾṖƊ}), Ṿcrée une représentation sous forme de chaîne de la chaîne ( “ȮṾṖƊ}”) et Ṗsupprime le ”caractère. La chaîne “ȮṾṖƊ}est laissée après la monade et est implicitement imprimée.

38 49 36 octets

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

Essayez-le en ligne!

C'est la première fois que j'utilise un espace de golf Jelly.

La liste des nombres au début contient ordle reste des caractères dans le code. Après ça:

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 octets

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

Essayez-le en ligne!

Utilise des nombres et des index de base 250 dans la page de codes Jelly. Économisé 72 octets en changeant l'algorithme. J'utilisais chaque numéro pour indexer la page de codes de Jelly, mais je reconvertis maintenant l'entier en base 250, puis l'indexation dans la page de codes de Jelly, réduisant de moitié le nombre de littéraux dont j'ai besoin dans la première ligne. Cela réduit également le nombre de caractères uniques nécessaires, mais je ne peux pas penser à un moyen de créer plus de quines.

J'ai utilisé ce ⁾“”qui crée des littéraux de chaîne Ọet ØJqui crée des chaînes à partir de nombres. Je ne peux penser à aucune autre façon de faire des cordes. J'ai toujours le chiffre 9et ‘’disponible, donc s'il y a une autre façon de faire des chaînes à partir de nombres, il peut être possible de faire une autre quine.

Haskell , 3 quines, 1119 octets

Quine 1, 51 octets

Une IOaction anonyme imprimant directement sur stdout.

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

Essayez-le en ligne!

Quine 2, 265 octets

La fonction fprend un argument fictif et renvoie une chaîne.

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]

Essayez-le en ligne!

Quine 3, 803 octets

Tout ce qui suit le LANGUAGEpragma est une fonction quelconque qui prend un argument fictif et renvoie une chaîne.

{-#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'

Essayez-le en ligne!

Personnages

Quine 1:

"S`adeimnprtu

Quine 2:

	!+,.0123456789;<=[]bcfghosw

Quine 3:

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

Comment ça marche

Quine 1

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

Quine 1 est une version modifiée de mon récent Golf you a quine answer (avec des améliorations de H.PWiz):

• Étant donné que les programmes complets ne sont pas nécessaires, main=a été supprimé.
• <>et $ont été remplacés par leurs quasi-synonymes mappendet id.

Cela libère les caractères vitaux =<>et l'opérateur utile $pour les autres quines.

Quine 2

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

Quine 2 utilise des méthodes quelque peu similaires pour programmer 2 de ma récente réponse Mutuellement Exclusif Quines , mais adapté pour se quine directement et surtout pour éviter d'utiliser des littéraux de caractères, qui sont nécessaires pour la quine 3. Ces deux sont obtenus à l'aide de la showfonction, qui, par pure chance, n'a encore utilisé aucun de ses personnages.

Cette quine utilise des tabulations au lieu d'espaces, mais j'ai utilisé les espaces ci-dessous pour plus de lisibilité.

• gcorrespond aux données de quine, sous la forme d'une liste d'entiers à la fin du code. Chaque numéro représente un caractère du reste du code.
  • Les nombres sont décalés de 9, donc cet onglet l'est 0. Cela rend l'encodage un peu plus court en permettant aux lettres minuscules de la fonction et aux noms de variables de tenir sur 2 chiffres.
• b c=[[[show 9!!0,show 1!!0..]!!6..]!!c] est une fonction pour convertir un nombre en caractère (en fait une chaîne à un caractère).
  • [[show 9!!0,show 1!!0..]!!6..]est une plage de caractères commençant par un caractère de tabulation, qui est indexé dans avec !!c.
  • Le caractère de tabulation est lui - même produit par l' indexation dans une autre plage [show 9!!0,show 1!!0..], en commençant par les caractères numériques '9'et '1'et sautant par pas de huit.
  • Les caractères numériques sont produits par indexation dans la showchaîne du chiffre correspondant.
• f c=[b=<<g]!!0++show gest la fonction principale. cest un argument factice.
  • b=<<gutilise =<<pour convertir chaque nombre en gson caractère. (L'utilisation de =<<plutôt que par exemple mapest la raison bpour laquelle il faut envelopper son caractère retourné dans une liste.)
  • show gdonne la représentation sous forme de chaîne de gla liste de et ++concatène les chaînes.
  • Parce qu'il =<<a une priorité inférieure à ++, un certain bracketing est nécessaire. Pour éviter d'utiliser ()(réservé au quine 3), [...]!!0indexe dans une liste avec un élément.

Quine 3

De par la conception des autres quines, quine 3 a toujours accès aux parenthèses, aux expressions lambda, aux littéraux de caractères et au constructeur de chaîne / liste :. Ce sera suffisant pour construire une fonction qui ajoute le code du quine à une chaîne.

Malheureusement, toutes les voyelles minuscules (sauf parfois y) ont été utilisées, ne laissant aucune fonction intégrée alphanumérique utile. Sont également []""partis. Cela ne laisse aucun moyen normal de construire une chaîne vide pour commencer à faire semblant le code.

Cependant, presque toutes les lettres majuscules sont toujours disponibles, donc un LANGUAGEpragma pour obtenir une extension de langue est possible. Encore une fois, par pure chance, CPP(activer le préprocesseur C) est la seule extension de langage nommée avec uniquement des lettres majuscules. Et les macros CPP ont souvent des noms en majuscules.

Ainsi, pour obtenir la chaîne vide essentielle, le quine permet CPP, utilise la __TIME__macro pour obtenir une constante de chaîne de la forme "??:??:??"(il est commodément garanti de toujours avoir la même longueur), et le modèle correspond.

{-#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&'{'&'-'&......

Après le pragma du langage, le quine consiste en une expression lambda liant ses paramètres à ces quatre arguments (laissant un paramètre factice final _à appliquer plus tard):

• qlié à '\'', donnant un caractère de guillemet simple;
• _:_:_:_:_:_:_:_:zlié à __TIME__, alias une chaîne similaire "??:??:??", créant ainsi zune chaîne vide;
• ylié à (\(?)v k x->v$k?x), un combinateur lambda utilisé pour aider à convertir les données de quine de la forme associée à gauche ("foldl") à la forme associée à droite ("foldr");
• L'opérateur (#)lié à \(&)(%)v->v&'{'&'-'&..., les données quine lui-même.

Les données de quine sont données sous une forme de codage Church, une expression lambda avec des paramètres (&)(%)v.

• En appliquant l'expression à des valeurs particulières pour instancier (&), (%)et v, cet encodage peut être utilisé soit pour construire le code principal du quine, soit pour reconstruire la représentation des données du quine elle-même.
• Par la règle de fixité par défaut de Haskell, &et %devenez des opérateurs associatifs gauches à l'intérieur du lambda. Ainsi, les paramètres des caractères se combinent avec l'initiale en vpartant de la gauche.
• Pour la plupart des personnages k, il existe un correspondant &'k'.
• Quand kest 'ou \, qui doit être échappé à l'intérieur des littéraux de caractères, le codage est à la place %'\k'.

Étant donné que le codage des données est associatif à gauche, mais que les chaînes sont construites de manière associative à droite, le combinateur y = (\(?)v k x->v$k?x)est introduit pour combler le décalage.

• y(...)est destiné à construire des fonctions appropriées à utiliser comme données (&)et (%)opérateurs de quine .
• vest une fonction de chaînes en chaînes (les données prévues vsont des exemples).
• kest un caractère, xune chaîne et ?un opérateur qui les combine en une nouvelle chaîne. (Pour le code principal,. (?)=(:)Pour reconstruire réellement la représentation des données quine, c'est plus compliqué.)
• C'est donc y(?)v k = \x->v$k?xune autre fonction de chaînes en chaînes.

• Comme exemple de la façon dont cela change l'associativité, si (&)=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)

Plus généralement, quand (#)est la fonction de données quine et f1,f2sont des fonctions combinant des caractères avec des chaînes:

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

appliquer la fonction de données de quine avec (&)=y(f1)et (%)=y(f2), et cela utilise les éléments prescrits f1et f2pour combiner les caractères des données de quine avec x, puis passe la chaîne résultante à v.

Le corps de l'expression lambda principale met tout cela ensemble:

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

• '&':q:k:q:xpour un caractère kprécède &'k'la chaîne x, tandis que les '%':q:'\\':k:q:xpréfixes %'\k', qui sont leurs formes de données de quine d'origine.
• Ce y(\k x->'&':q:k:q:x)#y(\k x->'%':q:'\\':k:q:xsont donc les bons paramètres pour reconstruire la représentation des données de quine, ajoutés à la finale z(la chaîne vide), puis passés à la fonction suivante.
• y(:)#y(:) sont les bons paramètres pour ajouter le code de base du quine à une chaîne, sans autre modification.
• Enfin, le \x->xfait de ne rien faire avec le quine construit, qui est retourné.

Perl 6 , 3 quines, 274 octets

Quine 1, 52 octets

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

Essayez-le en ligne!

Quine 2, 102 octets

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]))

Essayez-le en ligne!

Quine 3, 120 octets

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

Essayez-le en ligne!

Vérification d'ensembles d'octets distincts

Il y avait beaucoup de manœuvre pour obtenir ce troisième quine. Perl 6 dispose de 4 méthodes de production (que je connais), say, put, printet printf. Les deux sayet la putsortie des nouvelles lignes, car je ne peux pas utiliser les deux. put, print, printfContiennent tous pet t. Nous pouvons contourner cela partiellement en utilisant EVALpour utiliser les majuscules PRINT. À partir de là, je ne pense pas qu'il soit possible d'obtenir 4 quines ... (même si peut-être quelque chose comme ça shell "echo 'quine'"pourrait fonctionner)

Nous pouvons ensuite contourner les problèmes d'espacement en utilisant différents types d'espaces pour séparer les opérateurs, les espaces, les tabulations et les retours à la ligne.

Explications:

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:

Il s'agit d'une quine au format printf |(q[printf q[%s]]xx 2), c'est-à-dire qu'elle formate une copie de la chaîne en elle-même. Cependant, nous ne pouvons pas l'utiliser scar il est utilisé dans les quines précédents say. Nous utilisons donc la chaîne OU opérateur ( ~|) sur @et !3, pour produire la %spartie, mais nous ne pouvons pas le faire à la fois pour la chaîne de format et la chaîne à insérer, nous devons donc faire Z~avec la chaîne supplémentaire et une chaîne vide, bien que nous ne puissions pas ensuite utiliser ,pour séparer les deux, nous faisons donc Xx qw[1 0]pour multiplier les chaînes par 1 et 0.

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:

Il s'agit d'une quine EVAL qui fait de son mieux pour tout mettre en majuscules afin d'éviter tout conflit avec les autres quines. Cela implique beaucoup de EVALs ainsi que quelques lc- uns et ucde convertir entre les cas.

<...>.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 octets

9 octets

ÿ'ÿ⌐_'ÿ⌐_

Essayez-le en ligne!

45 octets

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

Essayez-le en ligne!

49 octets

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

Essayez-le en ligne!

99 octets

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

Essayez-le en ligne!

4488 octets

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

Essayez-le en ligne!

188 845 octets

Je ne peux pas vraiment faire de lien avec celui-ci, alors voici un programme Perl 6 qui génère le quine réel

Vérification de la distinction

Je peux très certainement en extraire une autre quine, bien que je pense que je n'ai plus de moyens de pousser les chaînes directement dans la pile, donc je devrai recourir à des méthodes plus étranges. Des méthodes encore plus étranges arrivent alors que j'essaie une sixième quine. Dans certains cas, les quines pourraient être plus courtes, mais je réduis les octets utilisés en préparation.

D'accord, je pourrais techniquement être en mesure de faire une autre quine, car j'ai encore quelques opérateurs dont j'ai besoin (chaîne de poussée, chaîne d'incrémentation, duplication, mappage, popping), c'est le bouclage qui nous restreint. Ce {}sont les seuls opérateurs qui peuvent indiquer un bloc de code de longueur arbitraire, et j'en ai vraiment besoin dans la 6e quine. Je pourrais utiliser certains des autres blocs de code, mais ils sont limités, et je doute que les sections de bouclage soient aussi courtes, car nous manquons d'opérateurs faciles.

D'accord, quelques explications tardives:

Tous les quines ont presque la même structure:

• Envoyez une chaîne, une liste de chaînes ou une liste de caractères à la pile.
• Combinez le tout dans une seule liste
• Dupliquer la liste
• Cartographier la copie, imprimer / pousser les caractères utilisés pour obtenir les caractères originaux
• Imprimer la liste originale des caractères sous forme de chaîne

Quine 1:

C'est fondamentalement le même que celui que j'ai posté dans la question normale.

ÿ'ÿ⌐_'ÿ⌐_
ÿ            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:

La raison pour laquelle cette quine est tellement plus longue que les autres est que l'incrémentation des chaînes utilise des représentations unicode, ce qui aspire vraiment certains des caractères du code, surtout lorsque nous essayons de créer le caractère ⌂dans le code, ce qui gonfle le code de plus de 8000 caractères, ce qui gonfle alors la partie représentation de très grande ampleur.

⌂         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

Ce dernier quine serait considérablement réduit si MathGolf était cohérent sur l'utilisation ou non de la page de code native par les chaînes.

Python 2, 2 quines, 434 353 349 446 octets

C'était surtout pour voir si je pouvais le faire en Python.

30 octets (y compris une nouvelle ligne de fin):

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

et 416 octets, sans retour à la ligne:

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

(Golfé 81 octets grâce à Lynn mais a ajouté une charge en raison de l'attention portée à la nouvelle ligne.)

Explication

Le premier est juste le quine Python court standard , mais modifié pour ne pas être utilisé _. Comme il s'agit de Python 2, il n'utilise pas non plus (ou ).

Le second a réfléchi. La longue chaîne est codée à l'aide du hexcodec (garantissant ainsi qu'elle ne contiendra que 0- 9et a- f) et décode comme

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")')

Cela utilise la supercherie quine pour obtenir son propre code source, puis l'encode en utilisant hex_codec, puis l'imprime entouré exec"".decode("hex"), en utilisant sys.stdout.writepour éviter d'imprimer une nouvelle ligne. L'exécution de ce code génère le deuxième quine, c'est ainsi que je l'ai généré.

Je soupçonne que plus de deux est impossible en Python, bien que j'aimerais le voir si je me trompe!

Si cela ne vous dérange pas eines quines

Ørjan Johansen a suggéré ce qui suit pour le deuxième quine pré-encodé

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

ce qui donnerait 30 + 248 = 278 octets pour la sortie suivante:

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

L'utilisation de execcette manière ne triche pas selon les règles de quine appropriées de PPCG mais cela me semble un peu tricheur (élégant et intelligent, mais toujours tricheur), car certains caractères sont utilisés à la fois comme code et données. (Bien que ma version utilise exec, le code et les données sont séparés.) Je vais donc garder mon score à 446.

Japt , 2 3 quines, 106 172 octets

Le premier est une version assez verbeuse de ma réponse N quine quine .

[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¹¬]¬

Essayez-le ici .

La deuxième quine est une plus grande bonne quine d'ETHProduction , qui est une bonne quine standard pour Japt.

"iQ ²"iQ ²

Essayez-le ici .

Le troisième utilise ``et code XORing pour stocker les données.

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

Essayez-le ici .

Puisqu'ils ()'sont toujours disponibles, il pourrait être possible d'en extraire une autre quine.

Gol> <> , ₂ 3 quines, _{17 28 27} 26 octets

6 octets

"r2ssH

Essayez-le en ligne!

_{11 10} 9 octets

'3d*Wo{|;

Essayez-le en ligne!

11 octets

Eh`#Ma0piS0

Essayez-le en ligne!

Gol> <> a trois façons d'imprimer n'importe quel caractère:

• o Pop une valeur et imprimer en tant que char
• H Tout éclater, imprimer en tant que caractère et arrêter
• S"..." Imprimer le littéral de chaîne sans affecter la pile du tout

Mais je ne pouvais pas trouver un moyen d'écrire une quine en utilisant S"..."comme seule méthode de sortie, j'ai donc trouvé les deux ci-dessus, en utilisant les deux types de littéraux de chaîne.

Le troisième (par Jo King) utilise la pcommande pour créer l'entrée "à S"la volée, qui à son tour imprime tout sauf le zéro à la fin. EhImprime ensuite le zéro et quitte.

Maintenant que nous avons utilisé toutes les commandes de sortie ET la pcommande, je pense qu'il est impossible de créer une autre quine (sauf si quelqu'un propose la S"quine sans p).

Ruby , 2 quines, 27 + 44 = 71 octets

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

Essayez-le en ligne!

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

Essayez-le en ligne!

Je suis principalement limité par les méthodes de sortie, ici. Il existe plusieurs façons de manipuler les chaînes, mais à part $><<toutes les méthodes de sortie utilisables semblent se recouper trop. Je pense qu'il pourrait y avoir une issue, evalmais il est difficile d'avoir à imbriquer plusieurs manipulations de cordes de différents types.

Javascript ES6, 2 quines, 43 + 22 = 65 octets

Quine 1:

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

Quine 2:

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

> <> , 2 quines, 8 + 16 = 24 octets

8 octets

#o<}-1:"

Essayez-le en ligne!

Tiré de cette réponse .

16 octets

'r3d*d8*7+e0p>>|

Essayez-le en ligne!

Ceci est basé sur le 'r3d*>o<quine, à l' exception oet <ne peut pas être utilisé, de sorte que je l' ai remplacé <avec |et créé de manière dynamique o(111 = 8 * 13 + 7) et placée là où le deuxième >est.

2 quines est la limite

Malheureusement, nous sommes limités par le nombre de commandes de sortie. nn'est pas utile car il ne produit que des nombres, il odoit donc être exécuté dans n'importe quelle quine. La seule façon de créer dynamiquement oest avec p. Une quine peut donc être utilisée oet une autre peut la créer avec p, mais il ne peut y avoir de 3e quine.

Il pourrait être possible qu'un troisième quine laisse le code source sur la pile si cela compte.

Java 10, 2 quines, 1448 1248 octets

1350 1122 octets

\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

Essayez-le en ligne.

Équivalent à:

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));}

Explication:

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 octets

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()retournera nullquand aucun n'est fourni, donc TIO retourne un NullPointerExceptiondans ce cas .

Pour prouver qu'il s'agit d'un quine fonctionnel, remplacez-le System.console()par System.out: Essayez-le en ligne.

Explication:

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

Explication générale:

En Java, une quine se fait généralement comme ceci:

• Le String scontient le code source non formaté.
• %sest utilisé pour entrer cette chaîne en elle-même avec le s.format(...).
• %c, %1$cEt le 34sont utilisés pour formater les guillemets doubles.
• s.format(s,34,s) met tout cela ensemble.

Dans ce cas, la fonction lambda quine la plus courte en Java 10 serait la suivante ( 82 octets ):

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

Essayez-le en ligne.

Étant donné que la seule façon d'avoir deux quines en Java est d'utiliser la version unicode avec \uHEXA, qui est convertie en caractères lors de la compilation, je ne peux pas utiliser les caractères 0123456789ABCDEF\udans la version non unicode. Ainsi, la version non unicode plus petite utilisera à la System.console()place de returnou System.out(les deux contenant un 'u'), et utilisera '}'-'['et deux fois %cau lieu de 34et %1$c.

Quelques points à noter sur la version unicode:

• Je suis volontairement en utilisant %04Xau lieu de %04x(pour les majuscules hexadécimales au lieu de minuscules).
• J'utilise 92, %cet %3$cpour formater les barres obliques.
• L'utilisation d'un majuscule \Uau lieu de minuscules \un'est pas autorisée apparemment, sinon j'aurais juste utilisé returndans la version non-unicode plus courte.