Ecrivez un programme (ou une fonction) (appelons-le P1) qui, une fois lancé, génère un autre programme P2 du même langage, avec exactement un octet de plus que P1.

Le programme P2, lorsqu'il est exécuté, devrait générer un 3ème programme P3 de 1 octet plus long que P2. P3 doit sortir un programme P4 plus long d'un octet que P3, etc. Il en va de même pour P5, P6, ..., P.

La chaîne de programmes doit aller indéfiniment ou dans un endroit où l'interprète ne peut plus gérer (mais doit rester un programme théoriquement valide dans la langue)

Règles

• Lacunes standard interdites
• Tous les programmes de la chaîne doivent être dans une langue
• Aucune entrée n'est donnée. La sortie passe à stdout ou à la valeur de retour de la fonction
• Le programme doit se terminer après un certain temps. Un programme qui arrête de générer une sortie après un certain intervalle de temps mais ne se termine jamais n'est pas éligible

Le programme le plus court P1 en octets dans chaque langue gagne!

JavaScript (ES6), 14 12 octets

-2 octets grâce à @Shaggy

f=_=>"f=_"+f

Extrait de test

s=`f=_=>"f=_"+f`;

for(i=10;i--;s=eval(s)())
  o.innerText+=s+"\n";

<pre id=o></pre>

7 , 4 octets d'ASCII

1603

Essayez-le en ligne!

Je sais que 7 n'est pas normalement codé en ASCII, mais cette fois, il s'agit d'un codage plus pratique, de sorte que nous ajoutons 1 octet à chaque exécution, et non 3 bits.

Je ne suis pas sûr non plus que cela compte pour la triche ou non. (Il est habituel de ne pas savoir si un 7-quine est en train de tricher, car il chevauche la limite de plusieurs façons.) Vous pouvez argumenter de manière décente que le 0code code le 6, mais en général, on ne sait pas exactement d'où viennent les caractères qui en résultent. "dans 7 parce qu'il a tellement de comportements implicites, assez bizarres.

Ce programme s’imprime avec les éléments 1ajoutés et le fera même si vous y ajoutez un certain nombre de 1s. Voici une trace de débogage commentée de 160311:

|| 160311      Initial data ||; initial program 160311
||7 60311      1 command = append 7 to data
|1 0311        6 command = escape from the last | onwards (7 escapes to 1)
|16e77         0311 commands = append 6e77 to data
|16e77 16e77   Implicit (program is empty): copy data past last | to program
|16e777 6e77   1 command = append 7 to data
71603111 e77   6 command = escape from the last | onwards
71603111 e77   e7 command = output in same encoding as the source

(Il ne |reste plus rien dans le programme, donc le equittera immédiatement en tant qu’effet secondaire, ce qui signifie que la finale 7ne sera jamais exécutée).

La confusion fondamentale à propos de la provenance de tous les caractères est que la plupart des commandes sur 7 ne produisent que des données lors de leur exécution, puis 6tente de reconstruire une séquence de commandes qui produirait le fragment de données donné; cela finit souvent par se rapprocher de l'original, sans toutefois l'identifier. (Pour des raisons de quining, vous écrivez normalement un programme de telle sorte que le résultat soit presque identique, différant normalement entre les deux titres 7.) Ainsi, par exemple, 1les données deviennent 716, ce qui est le moyen le plus facile de 1à la chaîne de données actuelle. Nous l'avions initialement produit avec 16une séquence de caractères différente (mais similaire), éliminant de manière destructive l'un des|marqueurs les données ont commencé avec. (J'imagine que le meilleur argument selon lequel il ne s'agit pas d'une quine littérale, c'est que la sortie est différente de l'entrée!)

Haskell , 74 66 octets

MODIFIER:

• -2 octets par H.PWiz en utilisant <>, puis -6 en déplaçant le (10*)<$>.

Ceci utilise maintenant le nouvel <>opérateur libre ( Semigroupmultiplication, nécessite que GHC 8.4 fonctionne sans importation.)

main=putStr$fst<>show$(10*)<$>("main=putStr$fst<>show$(10*)<$>",1)

Essayez-le en ligne! (Cheats avec une importation puisque TIO n'a pas encore GHC 8.4.)

Comment ça marche

• main=putStr$ est boilerplate pour sortir la valeur de chaîne suivante.

• fst<>showest une fonction qui prend un tuple et retourne une chaîne constituée du premier élément du tuple concaténé avec la représentation sous forme de chaîne du tuple. C'est à dire

  (fst<>show)(s,t) = fst(s,t)<>show(s,t) = s++show(s,t)

• (10*)<$>multiplie le dernier élément du tuple suivant par 10, en ajoutant un chiffre 0à sa représentation sous forme de chaîne.

C (gcc) , 134 132 octets

Légère retouche de la quine canonique. Terriblement long.

x;*s="x;*s=%c%s%c;main(i){for(i=__LINE__;i--;puts(&x));printf(s,34,s,34);}";main(i){for(i=__LINE__;i--;puts(&x));printf(s,34,s,34);}

Essayez-le en ligne!

Fission 2 , 7 octets

'!+OR!"

Essayez-le en ligne!

La série Fission standard , mais avec un extra !qui imprime un 0x01 supplémentaire au début du code à chaque itération.

Pari / GP , 35 octets

(f=(x)->print1("(f="f")("1x")"))(1)

Essayez-le en ligne!

Python 2 , 38 octets

s="print's=%r;exec s'%(s+'#')";exec s

Essayez-le en ligne!

brainfuck , 420 octets

->+++>>+++>+>++>+++>+>+>+++>>>>>>>>>>>>>>>>>>>>+>+>++>+++>++>>+++>+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+>+>>+++>>+++>>>>>+++>+>>>>>>>>>++>+++>+++>+>>+++>+++>+>++>>+++>+>+++>+>++>+++>>>+>+>++>+++>+>+>>+++>>>>>>>+>+>>>+>+>++>+++>+++>+>>+++>>>+++>+>++>+++>++>>+>+>++>+++>+>+>>+++>>>>>+++>+>>>>>++>+++>+++>+>>+++>>>+++>+>+++>+>>+++>>+++>>++[[>>+[>]++>++[<]<-]>+[>]<+<+++[<]<+]>>->[>]++++>++[[<++++++++++++++++>-]<+++++++++.<]>.

Essayez-le en ligne!

Il s’agit d’une modification du quine "standard" BrainFuck , avec un point .final qui pointe sur un extra à .chaque itération.

Le quine lui-même code les caractères de Brainfuck comme une pile de chiffres hexadécimaux: spécifiquement, les chiffres hexadécimaux de c-0x2b, qui sont commodément les suivants:

+: 0x00
-: 0x02
[: 0x30
]: 0x32
<: 0x11
>: 0x13
,: 0x01
.: 0x03

L'encodage couvre deux fragments de code: >++[[>>+[>]++>++[<]<-]>+[>]<+<+++[<]<+]>>->[>]++++>++pousse l'encodage de l'encodage lui-même, [[<++++++++++++++++>-]<+++++++++.<]parcourt la pile et imprime le tout.

Sale , 9 octets

'"n[!]a!␛

Essayez-le en ligne!

'   start and end a string literal
"   push a literal '
n   remove newlines
[!] print the string
a   push the alphabet
!   print the first character
␛   end the program

Si la lecture de code source est autorisée:

Sale , 8 octets

Q[!]W33!

Essayez-le en ligne!

A expliqué:

Q   push the source code
[!] print each character
W   clear the now-empty stack
33! print an exclaimation mark

Peut-être valide:

Sale , 4 octets

Q[‼]

Essayez-le en ligne!

Il imprime le code source avec une nouvelle ligne.
(Et un tas d'espaces, à cause d'un bug. Cela fonctionne pareil sans eux cependant.)

Notez que cela ne fonctionne que dans le jeu de caractères natif, et non lorsque vous utilisez le frontal UTF8. Par conséquent, pour l'essayer sur TIO, vous devez remplacer le caractère qu'il sort entre les []s ‼, ce qui correspond à l'équivalent UTF8. .

Java 8, 162 146 octets

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

Essayez-le en ligne.
Essayez le premier programme de sortie . Essayez le deuxième programme de sortie . Essayez le troisième programme de sortie .

Explication:

v->{                       // Method with empty unused parameter and String return-type
  String s="v->{String s=%c%s%1$c+1;return s.format(s,34,s).replaceAll(%1$c1+$%1$c,%1$c%1$c);}"
                           //  The unformatted source code
           +1;             //  Plus a random digit (1 in this case)
  return s.format(s,34,s)  //  Create the quine
          .replaceAll("1+$","");}
                           //  Then remove any trailing 1s

quine-part :

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

Défi:

• +1 ajoute un 1 aux programmes non formatés et formatés.
• .replaceAll("1+$","");}: Parce que nous voulons seulement augmenter le nombre d'octets du programme de un au lieu de deux, nous supprimons tous les 1 avant de revenir.

> <> , 9 octets

#o<:}-1:"

Essayez-le en ligne!

Variation sur un classique> <> quine, qui ajoute simplement une autre commande dupe pour copier le #au premier plan.

Perl 5 , 32 octets

$_=q{say"\$_=q{$_
};eval"};eval

Essayez-le en ligne!

GolfScript , 9 octets

{'.~1'}.~

Essayez-le en ligne!

CJam , 9 octets

{"_~1"}_~

Essayez-le en ligne!

Je publie ces deux solutions dans la même réponse, car elles ne sont que des variantes triviales et fonctionnent exactement de la même manière. Ils sont tous deux basés sur la quine commune de GolfScript {'.~'}.~(ou {"_~"}_~dans CJam), qui est décrite plus en détail, par exemple dans ma précédente réponse.

La seule différence est que cette variante ajoute un 1octet à la fin de sa sortie. En l'occurrence, toute chaîne de 1s (ou tout autre littéral entier sans zéros) est elle-même une séquence simple dans GolfScript et CJam. Par conséquent, les chaînes déjà présentes à la fin du code ci-dessus sont simplement copiées intégralement dans la sortie. Étant donné que GolfScript (et CJam) utilise des entiers de longueur arbitraire, cela fonctionnera pour des programmes de longueur arbitraire, du moins tant que l'ordinateur qui exécute le code dispose de suffisamment de mémoire pour le stocker.

Attaché , 76 72 61 octets

Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]]",Repr[x+sp]]

Essayez-le en ligne!

Quine standard qui ajoute un espace à la fin de xchaque itération.

Premières itérations:

Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]]",Repr[x+sp]]

Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]] ",Repr[x+sp]]

Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]]  ",Repr[x+sp]]

etc.

Attaché, 72 octets

y:=1Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]

Essayez-le en ligne!

Il s’agit simplement d’une variante du format standard quine, avec une variable ydéfinie 10*yaprès chaque itération

Les premières itérations:

y:=1Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]

y:=10Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]

y:=100Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]

etc.

Swift 4 , 89 octets

let(a,b)=(";print(\"let(a,b)=\\((a,b+\"-\"))\"+a)", "");print("let(a,b)=\((a,b+"-"))"+a)

Inclut un retour à la ligne

Essayez-le en ligne!

Haskell , 88 octets

main=putStr$snd(span(<'m')s)++show s;s='#':"main=putStr$snd(span(<'m')s)++show s;s='#':"

Essayez-le en ligne! Se développe en ajoutant des caractères #à la chaîne de données.

Stax , 20 à 18 octets

"34s+cTZL"34s+cTZL

Exécuter et déboguer

Génère un espace supplémentaire avant le 2e guillemet à chaque itération.

Explication

Utilise le programme "34s+cTZL "34s+cTZLpour expliquer.

"34s+cTZL "34s+cTZL
"34s+cTZL "            String literal
           34s+        Prepend a double quote, Now the string is `"34s+cTZL `
               cT      Copy and trim trailing spaces
                 Z     Put a 0 under the top of stack
                       Stack now (from top to bottom): `["34s+cTZL,0,"34s+cTZL ]`
                  L    Collect all elements on stack, from bottom to top
                       Implicit output, 0 is converted to space.

Jstx , 4 octets

£↕♣:

Essayez-le en ligne!

Enchantements runiques , 6 octets

"'<S@>

Essayez-le en ligne!

Celui-ci était bizarre. Tout ce que je devais faire était d'enlever un ~de la quine originale trouvée par Jo King .

Chaque exécution supplémentaire en ajoute une autre <à la fin, par exemple:

"'<S@><<<<<<<<<

Ce qui ne fait rien.

Copie directe de cette réponse sur un défi connexe. Il est juste arrivé que la taille augmente déjà d'un octet à chaque itération (l'argument fort pour que ce défi soit un doublon de celui-ci ou vice versa).

Gelée , 11 octets

“⁾;⁶;ØV” ṘV

Essayez-le en ligne!

Merveille , 33 octets

f\ @(-> ol) ["f\ ";f;";f1";#0];f1

Une variante intéressante sur la quine normale qui ajoute un 1 après chaque itération.

Progression:

f\ @(-> ol) ["f\ ";f;";f1";#0];f1
f\ @(-> ol) ["f\ ";f;";f1";#0];f11
f\ @(-> ol) ["f\ ";f;";f1";#0];f111
...

Explication

f\ @                               #. Sets f to a function that does the following:
    (-> ol) [                      #.   Output each:
             "f\ ";                #.     String for declaration of f
                   f;              #.     Formatted representation of f's function
                     ";f1";        #.     String for call of f
                           #0      #.     Argument passed into f
                             ];f1  #. Call f with 1 as the argument

L'un des aspects intéressants de cette quine est que Wonder peut travailler avec des nombres de précision arbitraire, de sorte que la progression ne soit pas interrompue après un certain nombre de valeurs.

ColdFusion, 277 octets

<cfset u=Chr(34)><cfset q="<cfset u=Chr(34)><cfset q=%s%s%s><cfoutput>%screateObject(%sjava%s,%sjava.lang.String%s).format(q,[u,q,u,Chr(35),u,u,u,u,Chr(35)])%s</cfoutput>
"><cfoutput>#createObject("java","java.lang.String").format(q,[u,q,u,Chr(35),u,u,u,u,Chr(35)])#</cfoutput>

Il s’agit d’une modification anodine de mon cycle ColdFusion qui ajoute une nouvelle ligne à chaque appel supplémentaire.

Testé localement sur lucee-express-5.2.6.60

Lot Windows, 38 36 octets

echo|set/p"=q">q&copy/b/y %0+q %0
::

Ce code crée un fichier appelé "q", contenant la lettre "q", puis l'ajoute au fichier d'origine. Notez que "::" est un alias pour "rem" qui ne nécessite pas d'espace supplémentaire.

Sauvegardé 2 octets grâce à user3493001.

Gol> <> , 7 octets

":r2ssH

Essayez-le en ligne! Essayez-le en ligne !! Essayez-le en ligne !!!

Il s’agit d’une simple variante du jeu classique Gol> <>, mais en ajoute une copie à Hchaque exécution. Étant donné que la Hcommande arrête le programme, des opérations supplémentaires Hà la fin ne modifient pas le comportement.

T-SQL , 175 octets

DECLARE @ VARCHAR(MAX)='DECLARE @ VARCHAR(MAX)=*SET @=TRIM(REPLACE(@,0x2a,CHAR(39)+@+CHAR(32)+CHAR(39)))PRINT @'SET @=TRIM(REPLACE(@,0x2a,CHAR(39)+@+CHAR(32)+CHAR(39)))PRINT @

J'ai d'abord écrit une quine SQL, puis je l'ai modifié pour ajouter un espace supplémentaire (quelque peu inspiré par cette réponse ).

Befunge-98 (PyFunge) , 22 19 octets

r:#,_ #;'D2/'<,,@;"

Essayez-le en ligne!

Ajoute un <avant la dernière "à chaque génération.

C # (compilateur interactif Visual C #) , 89 octets

var s="var s={0}{1}{0}+8;Write(s.Trim('8'),(char)34,s);"+8;Write(s.Trim('8'),(char)34,s);

Inspiré par la réponse de Kevin Cruijssen.

Essayez-le en ligne!