Programme qui crée des versions plus grandes de lui-même (quine-variante)

109

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.

PyRulez
la source
4
@ Kevin, La définition est récursive. Le résultat devrait être un programme dont le résultat est plus grand que lui-même, et une réponse à cette question. Donc, la sortie devrait être plus grande que la sortie, et la sortie devrait être encore plus grande, etc.
ugoren
8
Je pense que vous devriez clarifier vos règles. D'une part, tout code supplémentaire généré par un tel programme est "évidemment inutile"; d'autre part, tout code supplémentaire dans la sortie est "utile" en ce sens qu'il contribue à l'objectif de répondre à ce défi.
Jason C
5
Désolé de détruire votre défi. :^)
Justin
2
Je pense que ce défi serait beaucoup mieux en tant que concours de popularité qu’un code de golf. Cela permettrait beaucoup plus de créativité!
CorsiKa
30
Naturellement, un tel programme devrait s'appeler une quinine.
Jonathan Van Matre

Réponses:

89

GS2 (8636 , 0e octet)



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

Essayez-le en ligne!

Dennis
la source
3
N’est-ce pas techniquement non compétitif puisque gs2 est plus récent que le challenge?
DJMcMayhem
24
Cet engagement précède le défi de un mois et demi. Je viens de le tester, et cela fonctionne comme prévu.
Dennis
1
Comment est-ce pas une faille ???
Mama Fun Roll
14
@ MamfunRoll Pourquoi serait-ce? Ce n'est pas différent d'un programme Retina vide imprimant 1 , d'un programme Jelly vide imprimant 0 ou d'un programme Stuck vide imprimant Hello, World! .
Dennis
2
@Cyoce Il arrive tout simplement qu'une nouvelle ligne génère une autre nouvelle ligne dans GS2.
Esolanging Fruit
299

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
Justin
la source
32
Un programme 0 caractères dans une langue donnée, étant donné qu’il est valide, produira probablement 0 caractères. Et puisque 0 * x = 0 pour toute valeur finie x, je peux affirmer que mon programme en sortie est en réalité 9999999999999999 fois plus gros que le code source.
nitro2k01
39
@JohannesH. Pour tous les problèmes (résolubles), il existe un langage de programmation qui résout le problème en 0 caractères.
Cruncher
15
Je propose toujours que nous nommions ce "théorème de Cruncher", à moins que ce ne soit déjà découvert.
Erty Seidohl
22
Une caractéristique intéressante est qu'il contiendra également des 2*59^n-2instances de "Hello, world!", En raison du "h" dans "the".
AJMansfield
8
On dirait que tu as été battu.
PyRulez
118

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.

Ilmari Karonen
la source
196
{].'.~'}.~︵ ┻━┻
nitro2k01
2
bit.ly/1cQXJyA
Jason C
2
@ nitro2k01 mes premières pensées exactement: D
Songo
1
"Real" est-il entre guillemets parce que HQ9 + n'est pas réel ou parce que GolfScript n'est pas réel ou les deux?
Roger Pate
1
@thepiercingarrow le code source ressemble à ceci
Rod
108

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
Justin
la source
23
"Vous devez écrire un programme qui produira un code source qui est" La sortie n'est sans doute pas un code source. Et en outre, selon la définition de la sortie (si la sortie doit provenir spécifiquement de stdout), rien n’est réellement produit.
nitro2k01
43
@ nitro2k01 Je cite la même chose: "Vous devez écrire un programme qui générera du code source ". Tout est en code source. Mais seules certaines choses sont du code source valide . De plus, ce qui est considéré comme une sortie n’a pas été spécifié, la liberté m’est donc autorisée.
Justin
15
@PyRulez C'est vrai. J'ai exploité tes règles. Vous n'avez pas besoin d'accepter cette réponse. Lorsque j'ai posté ceci, je savais qu'une controverse allait suivre, avec de nombreux votes positifs et négatifs. J'ai décidé que cela en valait la peine, cependant.
Justin
29
Etes-vous sûr que le programme lui-même a imprimé la sortie? N'était-ce pas seulement le compilateur? Le programme n'est jamais compilé et n'est lui-même ni interprété ni exécuté. Il n'a donc pas été en mesure de produire de sortie.
VX
12
@ blabla999 Je ne suis pas d'accord - les gens ne tentent pas ces défis parce que quelqu'un d'autre fait quelque chose de fou. Nous nous mettons simplement au défi de le faire d'une autre manière. Comme le dit Mark Rosewater, "les restrictions engendrent la créativité"
corsiKa
79

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

QQ

C'est la sortie:

QQQQ
Victor Stafusa
la source
36
J'ai vu cela et j'ai pensé "Oh non, rien ne peut battre ça." J'ai commencé à essayer de trouver quelque chose, puis ça m'a frappé. J'ai donc posté une réponse.
Justin
1
@ Quincunx Bravo, votre réponse a été votée.
Victor Stafusa
4
@Quincunx Non, je pense que c'est le 2^2^ncas où le programme initial est la génération 0. La longueur est récurrente m -> m^2.
Vortico
3
@Vortico Bon point. Même si je l'ai mal dit, je voulais dire: à la longueur du code n, la sortie devient n^n. Cependant, c'est faux; quand la longueur du code est n, la longueur de la sortie estn^2
Justin
2
C'est drôle cependant car même les deux premières itérations sont des prétendants possibles à cette question.
PyRulez
29

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
Daniero
la source
17
Réponse inspirée par les Kaiser Chiefs
Ben Jackson
25

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.

Jozefg
la source
7
Je dirais que dans le calcul lambda, "utiliser" un terme lambda signifie calculer sa forme normale, sans effectuer une seule réduction bêta. En outre, un terme peut contenir plusieurs redex, par conséquent, "réduire un redex unique" est une opération ambiguë.
Petr Pudlák le
2
Vous avez raison, mais comme ce terme n’a pas de forme normale, il est logique d’en parler en termes de réduction progressive. Puisque lambda calcul n’a pas d’évaluation d’ensemble inhérente, je peux simplement définir «en cours d’exécution» le fait de réduire un redex unique au niveau supérieur de redex avec une sémantique d’appel par nom non?
Jozefg
3
Eh bien, les termes sans forme normale correspondent à des programmes sans terminaison. Et le problème avec le redex de niveau supérieur est qu’un terme peut avoir deux redex, l’un ne constituant pas un sous-terme d’un autre. Vous pouvez choisir un critère à réduire, mais je dirais que vous vous éloignez alors beaucoup de la sémantique standard du calcul lambda. (Quoi qu'il en soit, j'apprécie votre idée de roman.)
Petr Pudlák le
2
(λx.xxx) (λx.xxx): 20
Fabio F.
2
(λx. xx) (λx. xxx) réduit à celui en une seule étape
Ben Millwood
23

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 .

Jason C
la source
2
Au moment où j'écris ce commentaire, la page Wiki de Quine indique que lire dans le système de fichiers est une tricherie.
Lord Ratte
3
@ LordRatte D'autre part, le défi n'était pas d'écrire un quine.
Jason C
20

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.

Daniero
la source
16

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.

Thomas Baruchel
la source
15

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()
utilisateur1547129
la source
3
Ce n'est pas une quine. Voir la définition .
Petr Pudlák le
14
@ PetrPudlák Ni est aucun programme dans cette question. C'est un problème de quine-variante, pas de quining strict.
AJMansfield
6

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
blabla999
la source
5

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.

Jens Erat
la source
1
Vous avez peut-être encore une chance d'utiliser ed, vous ne voulez pas parcourir sa page de manuel ...
Jens Erat
4

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.

DocMax
la source
Vous pouvez enregistrer un octet au "f(f())"lieu de"f();f()"
Hedi
Cela ne semble pas fonctionner pour moi ...
Citron destructible
3

Windows .BAT, 25

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

Croît à un taux exponentiel.

Version SH équivalente ici .

Jason C
la source
3

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
Conor O'Brien
la source
3

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.

SuperJedi224
la source
3

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.

Barboteur
la source
2

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.

Brosse à dents
la source
2

PHP, 38

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

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

ComFreek
la source
Les points-virgules sont-ils du code inutile?
Justin
3
@ Quincunx Ils sont, vous avez raison. Cependant, que considéreriez-vous comme code utile?
ComFreek
Peut-être que vous pourriez mettre dans le ';'. Ensuite, vous auriez des sorties plus longues.
Justin
1
pourquoi pas <?=fgets(fopen(__FILE__,'r')).';';?
Ismael Miguel
1
;<?echo fgets(fopen(__FILE__,'r'));
Jimmy23013
2

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);
MT0
la source
3
+_+ =_=+1 pour les émoticônes
TuxCrafting
2

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

Stuart Olsen
la source
+1 pour Common Lisp. Il me semble que vous pouvez sauter `et ,?
daniero
@daniero Sans la citation, il ne fait qu'imprimer le programme original, sans jamais grandir. À ce stade, vous pouvez également omettre le commentaire suivant or:(print -)
Stuart Olsen le
2

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.

ML
la source
La sortie, lorsqu'elle sera exécutée, produira-t-elle une entrée valide?
PyRulez
Dans le premier exemple, la sortie est un code valide. C'est un littéral de chaîne contenant 5 périodes. Dans le deuxième exemple, entrer le message julia lui-même ne ferait rien. Je pensais simplement que le fait de donner à la réplique un caractère de nouvelle ligne en appuyant sur entrée produit une sortie plus longue que l'entrée.
ML
"....." produira-t-il une version plus grande de lui-même?
PyRulez
Ah, maintenant je comprends. Je viens de remarquer qu'il fallait que ce soit récursif ... le temps de corriger ma solution. Merci pour l'allusion.
ML
1
Je suppose que le code est conforme aux règles maintenant.
ML
2

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.

Oliver Ni
la source
Les deux instances de DDpeuvent être remplacées par Ð.
Emigna
1
Pourquoi non compétitif?
MD XF
2

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:

Un motif dans un automate cellulaire qui crée des copies de plus en plus grandes de lui-même.

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

Tanner Swett
la source
1

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
ub3rst4r
la source
Cela ne fonctionne pas tout à fait, %0est la commande utilisée pour appeler le script, qui peut ne pas avoir d’ .BATextension. Vous pouvez utiliser %~nx0pour obtenir le nom de fichier complet du fichier de commandes.
Jason C
@JasonC, autant que je sache, il n'a pas besoin .batd'être exécuté. Si le nom de fichier est execute.bat, vous pouvez entrer executeou execute.bat. Les deux vont marcher.
Ub3rst4r
Le fichier lui - même doit avoir une .batextension à exécuter , mais vous pouvez laisser l'extension lorsque vous l' exécutez (lorsque vous tapez une commande sans extension, Windows tente .com, .exepuis .batdans cet ordre). Si le nom de fichier est hello.bat, alors >> %0écrira un fichier nommé hello, qui n'est pas l'original hello.bat(et ne peut pas être exécuté).
Jason C
1

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.

ıʇǝɥʇuʎs
la source
1

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.

L3viathan
la source
1

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

n4melyh4xor
la source
Fonctionne également dans (variantes de) HQ9 +.
CalculatriceFeline
@CalculatorFeline in HQ9 + cela ne continuerait pas à augmenter.
Martin Ender