Code auto-croissant codee codeee codeeee

41

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!

code-golf quine iBug
la source

2

@ Οurous Quoi ??? Je n'ai pas ajouté cette étiquette moi-même ...

iBug

6

@iBug Quoi qu'il en soit, les soumissions sont-elles autorisées à lire leur propre code source?

Martin Ender

3

@iBug La balise "quine" l'interdit par défaut et rend généralement les réponses plus intéressantes. C'est à vous cependant.

Martin Ender

1

"puts <<2*2,2\nputs <<2*2,2\n\n2"grandit de 2 à chaque itération en Ruby. Je n'ai rien trouvé de mieux. : - /. Défi intéressant!

Eric Duminil

1

Double possible d'un programme créant des versions plus grandes de lui-même (variante quine)

FireCubez

Réponses:

28

JavaScript (ES6), 14 12 octets

-2 octets grâce à @Shaggy

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

Extrait de test

Afficher l'extrait de code

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

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

<pre id=o></pre>

Développer l'extrait

Herman L
la source

Cela m'a pris une seconde pour repérer ça. Sournois!

Shaggy

4

Quelqu'un peut-il expliquer s'il vous plaît, je ne peux pas comprendre, comment cela augmente-t-il?

htmlcoderexe

2

@htmlcoderexe "f=_"ajoute un supplément _avant le nom du paramètre, ce qui augmente sa longueur à chaque itération.

Herman L

9

7 , 4 octets d'ASCII

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

ais523
la source

9

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.

Ørjan Johansen
la source

1

Vous pouvez économiser au moins 2 octets avec(<>)

H.PWiz

@ H.PWiz Merci, vous en avez plus en bougeant (10*)<$>.

Ørjan Johansen

8

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!

gastropner
la source

7

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.

Martin Ender
la source

7

Pari / GP , 35 octets

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

Essayez-le en ligne!

Alephalpha
la source

4

Python 2 , 38 octets

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

Essayez-le en ligne!

totalement humain
la source

4

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.

Nneonneo
la source

3

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

Οurous
la source

1

La version à 4 octets est définitivement invalide.

Erik l'Outgolfer

3

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

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.

Kevin Cruijssen
la source

2

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

Jo King
la source

2

Perl 5 , 32 octets

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

Essayez-le en ligne!

Dom Hastings
la source

2

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.

Ilmari Karonen
la source

2

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.

Conor O'Brien
la source

1

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!

Herman L
la source

1

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.

Laikoni
la source

Vous pouvez enregistrer un bit en showajoutant plus qu’une chaîne et en utilisant un filtrage par motif. Essayez-le en ligne!

Ørjan Johansen

@ ØrjanJohansen Nice! Haskell Quine est une approche complètement différente, à l’exception de la norme sous-jacente, alors n'hésitez pas à la poster vous-même.

Laikoni

OK, si tu le penses.

Ørjan Johansen

1

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.

Weijun Zhou
la source

1

Jstx , 4 octets

£↕♣:

Essayez-le en ligne!

Quantum64
la source

1

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

Draco18s
la source

0

Gelée , 11 octets

“⁾;⁶;ØV” ṘV

Essayez-le en ligne!

utilisateur202729
la source

0

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.

Maman Fun Roll
la source

0

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

Dom Hastings
la source

0

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.

Peter Ferrie
la source

0

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.

Barboteur
la source

0

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

Razvan Socol
la source

0

Befunge-98 (PyFunge) , 22 19 octets

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

Essayez-le en ligne!

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

IQuick 143
la source

0

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!

Incarnation de l'ignorance
la source