Vous devez écrire un programme qui générera le code source qui est

1. Plus grand que le programme original (en termes de personnage)
2. Imprimera un autre programme plus grand que lui-même lors de son exécution (le nouveau programme constitue également une réponse valable à ce défi)

C'est du code-golf, donc la réponse la plus courte gagne.

GS2 (8636 , 0e octet)

Ceci imprime une nouvelle ligne, qui imprime deux nouvelles lignes, qui en imprime trois, et cetera.

Essayez-le en ligne!

H9 + : 1 caractère

9

C'est vrai. Un personnage. Affiche les paroles de 99 bouteilles de bière , ce qui est un programme valide. Toutes les données superflues ne comptent pas, mais il y a beaucoup de choses 9là-dedans.

La sortie du programme généré est les paroles de 99 bouteilles de bière 59 fois.

Cette fonction donne le nombre de fois que les paroles sont sorties si vous exécutez le programme n(si mon calcul est correct):

f(n) = 59n-1

GolfScript, 9 caractères

{.'.~'}.~

Ce code affiche:

{.'.~'}{.'.~'}.~

qui produit:

{.'.~'}{.'.~'}{.'.~'}.~

qui produit:

{.'.~'}{.'.~'}{.'.~'}{.'.~'}.~

etc.

Je crois que c'est la réponse la plus courte dans un "vrai" langage de programmation complet de Turing jusqu'à présent.

Explication:

Fondamentalement, le code original ci-dessus est un "quine-layer": il génère un quine normal suivi de lui-même.

Dans GolfScript, tout littéral de bloc de code (par exemple {foo}), s'il n'est pas perturbé sur la pile, est une séquence. Ainsi, par lui-même, {.'.~'}sort simplement tout seul, comme le ferait n'importe quel autre bloc de code.

La .~fin du code prend le dernier bloc de code sur la pile, le duplique et exécute la copie. Lorsqu'il est exécuté, le code .'.~'à l'intérieur du bloc de code duplique l'élément le plus haut de la pile (c'est-à-dire sa copie) et ajoute la chaîne .~.

À la fin du programme, l'interpréteur GolfScript stringie et affiche tout ce qui se trouve sur la pile, qui, dans ce cas, consiste en un {.'.~'}bloc de plus que dans l'entrée, plus la chaîne .~.

Prime:

Ajouter un ]avant le premier .(pour rassembler tous les blocs de code de la pile dans un tableau avant de les dupliquer) le fait croître de façon exponentielle:

{].'.~'}.~

les sorties:

{].'.~'}{].'.~'}.~

qui produit:

{].'.~'}{].'.~'}{].'.~'}{].'.~'}.~

qui produit:

{].'.~'}{].'.~'}{].'.~'}{].'.~'}{].'.~'}{].'.~'}{].'.~'}{].'.~'}.~

etc.

Java 7: 0 caractères

Enregistrer en tant que fichier Blank.java. Si vous enregistrez un fichier dans un autre fichier, remplacez toute instance Blankpar le nom de fichier approprié.

Ensuite, lancez en ligne de commande en compilant d'abord, puis en cours d'exécution. Si la compilation échoue, arrêtez.

J'énumère ceci en tant que Java 7, car il se peut que la sortie diffère d'une version à l'autre.

Premières sorties (sorties sur stderr):

Error: Could not find or load main class Blank

Blank.java:1: error: class, interface, or enum expected
Error: Could not find or load main class Blank
^
Blank.java:1: error: reached end of file while parsing
Error: Could not find or load main class Blank
                                              ^
2 errors

Blank.java:1: error: class, interface, or enum expected
Blank.java:1: error: class, interface, or enum expected
^
Blank.java:1: error:  expected
Blank.java:1: error: class, interface, or enum expected
                          ^
Blank.java:1: error:  expected
Blank.java:1: error: class, interface, or enum expected
                                     ^
Blank.java:1: error: as of release 5, 'enum' is a keyword, and may not be used as an identifier
Blank.java:1: error: class, interface, or enum expected
                                          ^
  (use -source 1.4 or lower to use 'enum' as an identifier)
Blank.java:1: error: = expected
Blank.java:1: error: class, interface, or enum expected
                                               ^
Blank.java:2: error:  expected
Error: Could not find or load main class Blank
     ^
Blank.java:2: error: ';' expected
Error: Could not find or load main class Blank
      ^
Blank.java:2: error: = expected
Error: Could not find or load main class Blank
                      ^
Blank.java:2: error: = expected
Error: Could not find or load main class Blank
                                   ^
Blank.java:2: error:  expected
Error: Could not find or load main class Blank
                                              ^
Blank.java:3: error: = expected
^
^
Blank.java:3: error: ';' expected
^
 ^
Blank.java:4: error: illegal start of type
Blank.java:1: error: reached end of file while parsing
     ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
          ^
Blank.java:4: error: illegal start of type
Blank.java:1: error: reached end of file while parsing
           ^
Blank.java:4: error:  expected
Blank.java:1: error: reached end of file while parsing
            ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
          ^
Blank.java:4: error: illegal start of type
Blank.java:1: error: reached end of file while parsing
           ^
Blank.java:4: error:  expected
Blank.java:1: error: reached end of file while parsing
            ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
              ^
Blank.java:4: error: ';' expected
Blank.java:1: error: reached end of file while parsing
                   ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
                                 ^
Blank.java:4: error:  expected
Blank.java:1: error: reached end of file while parsing
                                        ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
                                         ^
Blank.java:4: error: ';' expected
Blank.java:1: error: reached end of file while parsing
                                              ^
Blank.java:5: error:  expected
Error: Could not find or load main class Blank
     ^
Blank.java:5: error: ';' expected
Error: Could not find or load main class Blank
      ^
Blank.java:5: error: = expected
Error: Could not find or load main class Blank
                      ^
Blank.java:5: error: = expected
Error: Could not find or load main class Blank
                                   ^
Blank.java:5: error:  expected
Error: Could not find or load main class Blank
                                              ^
Blank.java:6: error: = expected
                                              ^
                                              ^
Blank.java:6: error: ';' expected
                                              ^
                                               ^
Blank.java:7: error: reached end of file while parsing
2 errors
        ^
30 errors

HQ9 +, HQ9 ++ et similaires, 2 caractères

QQ

C'est la sortie:

QQQQ

Ruby 27

Une version très légèrement modifiée de cela ( via ):

puts <<3*3,3
puts <<3*3,3
3

Le nombre de fois que puts-line est imprimée augmente de manière exponentielle.

$ ruby quine.rb | ruby | ruby
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
3

$ ruby quine.rb | ruby | ruby | ruby | ruby | ruby | ruby | ruby | wc -l
    3283

Lambda Calculus - 29

Un simple terme lambda

(λu.(u u)(u u))(λu.(u u)(u u))

Réduire ce terme d'un rendement de réduction bêta

((λu.(u u)(u u))(λu.(u u)(u u)))((λu.(u u)(u u))(λu.(u u)(u u)))

Ainsi de suite. C'est une variante simple du classique (λu.u u)(λu.u u)qui est un quine in lambda calcul. Double application, nous obtenons ici deux fois plus de résultats.

Script SH, 9

cat $0 $0

Croît à un taux exponentiel.

Exécutez-le sh whatever.shou définissez-le comme exécutable.

La version Windows est ici .

dc 11

Assez facile:

6579792
dfP

La première ligne est répétée une fois par génération:

$ dc growing_quine.dc
6579792
6579792
dfP

$ dc growing_quine.dc | dc | dc 
6579792
6579792
6579792
6579792
dfP

La dernière ligne est composée des instructions suivantes: dduplique la dernière valeur placée sur la pile (6579792) (pour obtenir une copie supplémentaire à chaque exécution), fimprime la pile entière (qui est un groupe du même nombre) et Paffiche le nombre (6579792) sous forme de flux d'octets, qui s'affiche sous la forme dfP.

redcode (solution récursive)

C'est le code du guerrier le plus facile à écrire dans Redcode , le célèbre Imp:

MOV 0, 1

Lorsqu'il est exécuté, le code écrit une copie de sa seule instruction à l'adresse suivante en mémoire. puis l'exécute, etc.

Python 3 - 55

print(open(__file__).read())
f=lambda:print('f()')
f()

Cela pourrait être raccourci en remplaçant __file__ par un nom de fichier à caractère unique et en enregistrant le fichier ainsi, mais j’ai eu l’impression que cette réponse correspondait davantage à l’esprit de la question. Après une itération, il affiche:

print(open(__file__).read())
f=lambda:print('f()')
f()
f()

Smalltalk, 125 61 57

La version de golf semble presque illisible, donc je vais d'abord expliquer (et utiliser de vrais identifiants).

Il s'agit d'une variante de la méthode d'auto-modification "Le plus bizarre moyen de produire un dépassement de pile".

La méthode affiche un message Hello et sa source actuelle (pour la démonstration uniquement). Ensuite, le code est modifié pour générer une chaîne plus longue et installé. Enfin, le nouveau code est appelé de manière récursive.

Afin de me protéger d'une emballement immédiat, il permet à l'utilisateur de confirmer chaque cycle.

compiler dans Object:

eatMe_alice
   |msg mySource|

   mySource := thisContext method source.

   '**** Hello Alice' printCR.
   '  ---- my current code is:' printCR.
   mySource printCR.
   '  ---------------' printCR.

   (UserConfirmation confirm:'Again? ') ifTrue:[
       Object compile:
            (mySource
                copyReplaceString:'Hello ','Alice'
                withString:'Hello ','Alice !').
       self eatMe_alice
   ]

démarrez le spectacle en envoyant "eatMe_alice" à n'importe quel objet; nil fera:

nil eatMe_alice

Une variante intéressante consiste à ne pas appeler le nouveau code de manière récursive, mais itérative, en déroulant la pile d'appels et en entrant à nouveau dans la nouvelle méthode. Cela présente l'avantage de ne pas conduire à une exception de récursivité. Pour ce faire, remplacez l'appel récursif ("self eatMe_alice") par:

thisContext resend

Golf:

De toute évidence, l'impression et les appels à domicile n'étant pas demandés, le plus court (pour le golf) consiste simplement à ajouter un commentaire à ma propre source et à le renvoyer. Comme un effet secondaire, il est également installé pour le prochain appel ...

x|s|Object compile:(s:=thisContext method source,'""').^s

Script SH, 12 8 7

Stocker un fichier avec

sed p *

dans son propre répertoire vide et exécuté à partir de ce répertoire à l'aide de sh [file]ou set executable.

Ancienne alternative de 8 caractères , mais n’ayant pas besoin de son propre répertoire. Stocker un fichier avec

sed p $0

et exécuter en utilisant sh [file]ou définir un exécutable.

Ancienne alternative à 12 caractères :

sed -i- p $0

Cela va réellement sortir dans le fichier programme lui-même, mais l'endroit où sortir n'a pas été spécifié. Se réplique à un taux exponentiel.

JavaScript, 41 , 40 caractères

function f(){console.log(f+"f(f())")}f()

La première fois que vous l'exécutez, il en sort avec un autre ;f()à la fin. Des exécutions ultérieures des résultats de sortie dans chaque source "d'entrée" imprimée deux fois.

alertserait plus court que console.logmais je ne considère pas que plusieurs dialogues d'alerte soient "la" sortie alors qu'il semble raisonnable d'appeler plusieurs lignes dans la console en tant que sortie.

Windows .BAT, 25

@COPY %~nx0+%~nx0 CON>NUL

Croît à un taux exponentiel.

Version SH équivalente ici .

réticulaire, 11 octets, non compétitif

"'34'coo1o;

C'est le framework standard de Quine, sauf qu'un extra 1est imprimé après chaque itération. Essayez-le en ligne!

Premières sorties:

"'34'coo1o;
"'34'coo1o;1
"'34'coo1o;11
"'34'coo1o;111

Microscript II, 6 octets

Non compétitif, le langage postdate le défi.

"qp"qp

La première itération ajoute un extra qpà la fin et chaque itération suivante ajoute une copie supplémentaire de ce programme original au début.

J , 1 octet

'

Essayez-le en ligne!

La citation ouverte donne évidemment l'erreur de citation ouverte:

|open quote
|   '
|   ^
|[-1] /home/runner/.code.tio

Notez que, de par la nature de l'interpréteur J, les erreurs sont imprimées dans STDOUT et non dans STDERR.

Lorsque ce qui précède est exécuté en tant que code, il affiche:

|open quote
|   |   '
|       ^
|[-2] /home/runner/.code.tio

ensuite

|open quote
|   |   |   '
|           ^
|[-2] /home/runner/.code.tio

etc. Chaque fois que le code est exécuté, la deuxième ligne est complétée à gauche avec quatre octets |   , ce qui répond à l'exigence de ce défi.

J , bonne variante de quine, 25 octets

echo,~'echo,:~(,quote)'''

Essayez-le en ligne!

Les sorties

echo,:~(,quote)'echo,:~(,quote)'

Et puis, il sort deux fois, sur des lignes séparées:

echo,:~(,quote)'echo,:~(,quote)'
echo,:~(,quote)'echo,:~(,quote)'

ensuite

echo,:~(,quote)'echo,:~(,quote)'
echo,:~(,quote)'echo,:~(,quote)'
echo,:~(,quote)'echo,:~(,quote)'
echo,:~(,quote)'echo,:~(,quote)'

etc.

La première sortie est une variante simple de la norme J Quine . L'ajouté se ,:~concatène verticalement, où le tableau 2D résultant est imprimé sous forme de deux lignes de la même chaîne.

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.

EcmaScript 6 (51 octets):

(_=x=>'(_='+_+Array(x++).join(','+_)+')('+x+')')(2)

Il produit une version plus longue de lui-même, qui peut produire une version plus longue de lui-même, qui peut produire une version plus longue de lui-même, etc.

PHP, 38

<?echo fgets(fopen(__FILE__,'r')).';';

Il ajoutera un point-virgule à chaque exécution.

ECMAScript 6 (38 caractères)

(f=_=>'(f='+f+')();(f='+f+')();')();

Quelles sorties:

(f=_=>'(f='+f+')();(f='+f+')();')();(f=_=>'(f='+f+')();(f='+f+')();')();

Modifier

Vous pouvez faire (28 caractères):

(f=_=>'(f='+f+')();'+f())();

Cependant, il recurse à l'infini et ne retournera jamais rien ... mais cela peut être résolu en faisant quelque chose comme ceci (42 caractères):

(f=_=>_?'(f='+f+')('+_+');'+f(_-1):'')(3);

Quel sera le résultat:

(f=_=>_?'(f='+f+')('+_+');'+f(_-1):'')(3);(f=_=>_?'(f='+f+')('+_+');'+f(_-1):'')(2);(f=_=>_?'(f='+f+')('+_+');'+f(_-1):'')(1);

Common Lisp, 16 caractères

(print `(or ,-))

Certes, il est uniquement interactif, mais le fait de pouvoir référencer le formulaire de niveau supérieur actuel est probablement le meilleur moyen de minimiser un programme non trivial et conforme à la spécification.

Ce qui serait vraiment intéressant, c'est ce qui explose le plus rapidement. Peut-être quelque chose comme

(print `(progn ,@(loop repeat (length -) collect -)))

Julia, 66 caractères

x="print(\"x=\$(repr(x))\\n\$x;\"^2)";print("x=$(repr(x))\n$x;"^2)

Sortie (134 caractères):

x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);

Résultat de l'exécution du résultat (268 caractères):

x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);

résultat suivant (536 caractères):

x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);

Résultat suivant (1072 caractères):

x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);

J'espère que c'est selon les règles.

Il produit une sortie plus grande et la sortie elle-même est un code source valide qui produit à nouveau une sortie plus grande.

05AB1E, 15 octets, sans compétition

0"DÐ34çý"DÐ34çý

Essayez-le en ligne!

Impressions 0"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý,
qui imprime 0"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý,
etc.

Evoloop, rectangle 9 × 9 (81 cellules)

L' automate cellulaire Evoloop inclus avec Golly supporte des motifs qui se répliquent de manière "quine". Plus précisément, ces modèles contiennent chacun un "programme"; un motif se reproduit en exécutant d'abord le programme (qui crée le "corps" de la fille), puis en copiant le programme dans la fille.

Ce qui précède s’applique au plus célèbre automate cellulaire "Langton's Loops" ainsi qu’à Evoloop, mais Evoloop présente une différence intéressante, c’est qu’il est facile de créer un motif qui se développe à chaque génération.

(Beaucoup plus intéressant, à mon avis, est le fait qu'Evoloop est un simple automate cellulaire qui contient des motifs qui se reproduisent et évoluent de manière très réaliste! Je pense que les seuls automates cellulaires connus qui le font sont Evoloop et ses descendants Cependant, l’un des inconvénients d’Evoloop est qu’il existe un «meilleur» génome: l’évolution converge toujours vers ce génome.)

Maintenant, il y a deux lacunes à cette soumission. La première est qu’on ne sait pas ce qu’est la "sortie" d’un automate cellulaire. Mais je pense qu'un automate se reproduisant est "assez proche" pour être un quine; ce n'est certainement pas moins intéressant! L'autre inconvénient est que ces modèles ne créent pas simplement une copie d'eux-mêmes; chaque copie du motif original tente de créer une infinité de copies de lui-même et ces copies finissent par interagir de manière destructive. Donc, je pense avoir répondu aux exigences de ce défi dans l’esprit mais pas dans la lettre.

Sans plus tarder, le motif est le suivant:

022222220
270170172
212222202
202000212
272000272
212000202
202222212
271041032
022222250

Voici à nouveau le motif, dans un format qui peut être copié et collé dans Golly:

x = 9, y = 9, rule = Evoloop
.7B$BG.AG.AGB$BA5B.B$B.B3.BAB$BGB3.BGB$BAB3.B.B$B.5BAB$BGA.DA.CB$.6BE
!

D'accord, mais à quoi ça ressemble? Cela ressemble à ceci:

Dans l'animation ci-dessus, vous pouvez voir que le motif initial crée une fille plus grande, ce qui crée une petite-fille plus grande, puis une arrière-petite-fille plus grande et enfin un arrière-arrière-petite-fille encore plus grand qui commence à construire un troisième plus grand encore. petite fille. Si vous suiviez ce modèle pendant longtemps, il continuerait ainsi pour toujours (ou peut-être serait-il éventuellement dépassé par les organismes évolués, qui sont capables de se reproduire beaucoup plus rapidement; je ne suis pas sûr).

LOT, 26

Placez ce code dans n'importe quel fichier .bat et il continuera à s'exécuter (dans une boucle infinie) et le fichier s'agrandira également.

echo echo %0 ^>^> %0 >> %0

PYG (6)

P(Q,Q)

Imprime son propre code source, séparé par des nouvelles lignes. La deuxième génération serait

P(Q,Q)
P(Q,Q)

et ainsi de suite.

OIL , 83 octets

0
0
1
1
1
4
1
11
4
1
11
1
2
2
1
12
18
10
18
1
32
22
1
18
26
4
26
8
18
11
6
17
4
26

Il commence par imprimer deux lignes avec un zéro, puis compare chaque ligne à la ligne 1 si elles sont égales (ce qui est le cas lorsque le fichier est épuisé). Nous imprimons le contenu de la cellule 26. Le résultat obtenu sera alors idem, sauf avec un ajouté 33qui ne fait rien. La prochaine fois, une autre ligne sera ajoutée, et ainsi de suite.

Aidez-moi, WarDoq! , 1 octet.

H

Impressions Hello, World!.

Les autres caractères que H sont un code source valide (et sûr) (imprimant d’autres variantes de Hello World).