Générer des programmes de taille croissante

21

Dans ce défi, vous écrirez un programme qui sort un programme qui est le double de la longueur du programme d'origine. Le programme en sortie doit sortir un nouveau programme, un programme doublant sa longueur.

Exemples

Si mon programme est a:

< a
> aa

< aa
> aaaa

< aaaa
> aaaaaaaa

Règles

  • Pas de quine intégré
  • Le programme d'origine doit contenir au moins un octet
  • La séquence devrait théoriquement fonctionner à l'infini
  • Votre programme n'est pas autorisé à lire à partir de quoi que ce soit (fichier, stdio)

Votre score est de la taille du programme d'origine.

Downgoat
la source
Que diriez-vous d'accéder au fichier en se lisant / en accédant à l'endroit où le code est contenu?
Conor O'Brien
@ CᴏɴᴏʀO'Bʀɪᴇɴ ce n'est pas autorisé car cela violerait les règles je crois.
Downgoat
2
@ Doᴡɴɢᴏᴀᴛ les règles de quine sont recommandées par le tag wiki mais ne s'appliquent pas automatiquement
Martin Ender

Réponses:

12

CJam, 10 octets

{"_~"+_}_~

Testez-le ici.

Explication

{"_~" e# Generalised quine framework, leaves the block and the string "_~"
      e# on the stack. 
+     e# Prepend the block to the string.
_     e# Duplicate the resulting array.
}_~
Martin Ender
la source
GolfScript n'est pas mort! Ilmari a une réponse à une question similaire qui le fait en exactement 10 octets.
Justin
8

JavaScript, 62 61 37 octets


Merci à @ Doᴡɴɢᴏᴀᴛ pour l'aide!


Original [37 octets]:

f=_=>'f='+'_'.repeat((10+f).length)+f

Enfant [74 octets]:

f=______________________________________=>'f='+'_'.repeat((10+f).length)+f

Petit-enfant [148 octets]:

f=________________________________________________________________________________________________________________=>'f='+'_'.repeat((10+f).length)+f


Alternatif (avec impression sur console et en tant que programme complet):

Original [61 octets]:

f=_=>console.log(`f=${'_'.repeat((0+f).length+5)+f};f()`);f()

Enfant [122 octets]:

f=______________________________________________________________=>console.log(`f=${'_'.repeat((0+f).length+5)+f};f()`);f()

Petit-enfant [244 octets]:

f=________________________________________________________________________________________________________________________________________________________________________________________=>console.log(`f=${'_'.repeat((0+f).length+5)+f};f()`);f()



Comment ça fonctionne!

1.   f=_=>   Définissez la fonction f commeconsole.log(...)

2.   ;f()   Exécutez la fonction f.

3.   (dans la fonction f)  

  • console.log(...)   Imprimez ce qui suit:

    • f=   texte littéral "f ="
    • ${'_'.repeat((0+f).length+5)   "_" répété pour la longueur de f, modifié pour tenir compte des caractères non inclus dans la chaîne de f
    • +f}   La stringification de la fonction f
    • ;f()   texte littéral "; f ()"

Remarques

  • console.logest nécessaire au lieu de alertparce alertqu'il ne semble pas bien jouer avec des chaînes très longues (au moins sur ma configuration machine / navigateur)
  • Les _'sont insérés dans le nom du paramètre (inutilisé) de la fonction f, pour s'assurer qu'ils sont inclus dans la stringification de f.
  • Amélioration principale (en plus de se débarrasser de console.log) de la première solution par rapport à la seconde: ajouter 10à la fonction au lieu de la 0convertir en chaîne la rend un octet plus long, éliminant ainsi la nécessité d'ajouter 1 à la longueur par la suite, économisant un octet.
jrich
la source
0+fdevrait également fonctionner pour
convertir
48 octets:(f=_=>`(f=${'_'.repeat((0+f).length+5)+f})()`)()
Downgoat
@ Doᴡɴɢᴏᴀᴛ J'ai oublié que renvoyer le résultat est généralement acceptable. Mettra à jour.
jrich
@ Doᴡɴɢᴏᴀᴛ En fait, comme l'écriture des réponses en tant que fonctions est généralement acceptée, la solution doit-elle même appeler la fonction?
jrich
bien sûr, vous pourriez le faire
Downgoat
6

Minkolang 0,15 , 19 14 octets

"66*2-rIDdr$O.

Original , enfant , petit - enfant .

Explication

"66*2-      $O.    Standard quine formulation

      r            Reverse stack
       I           Push length of stack
        D          Pop n and duplicate top of stack n times
         d         Duplicate top of stack
          r        Reverse stack

Ce que le bit entre rles deux fait est de dupliquer la période de fin suffisamment de fois pour remplir le critère de doublage. .est le caractère "arrêter le programme", donc les nombreuses périodes à la fin ne font rien sauf être là.

El'endia Starman
la source
3

CJam, 12 octets

{"_~"1$1$}_~

Lors de l'exécution, cela imprimera

{"_~"1$1$}_~{"_~"1$1$}_~

qui, à son tour, imprimera

{"_~"1$1$}_~{"_~"1$1$}_~{"_~"1$1$}_~{"_~"1$1$}_~

etc.

Essayez-le en ligne!

Dennis
la source
2

Python 3, 51 octets

x=r"print('x=r\"'+x+'\"'+';exec(x*2)');";exec(x*2)

Cela inclut une nouvelle ligne de fin.

Quelles sorties:

x=r"print('x=r\"'+x+'\"'+';exec(x*2)');";exec(x*2)
x=r"print('x=r\"'+x+'\"'+';exec(x*2)');";exec(x*2)
Zweedeend
la source
2

GolfScript, 11 octets

{: ".~"]}.~

Essayez-le en ligne!

Comment fonctionne le code source

{: ".~"]}.~

{       }    Define and push a code block.
         .~  Push a copy and execute it.
 :           Save the code block in the space character.
             Every subsequent space will now execute the code block.
   ".~"      Push that string.
       ]     Wrap the entire stack in an array.

Si le code source ci-dessus est exécuté une fois, la pile se terminera comme

["" {: ".~"]} ".~"]

où la chaîne vide au début correspond à l'état initial de la pile (entrée vide).

Deux copies du code source laisseraient un état final de

[["" {: ".~"]} ".~"] {: ".~"]} ".~"]

etc.

Que se passe-t-il ensuite

Après avoir exécuté le code source, l'interpréteur effectue les opérations suivantes:

  1. Il enveloppe la pile entière dans un tableau et pousse ce tableau sur la pile.

    Pour une seule copie du code source, la pile contient maintenant

    ["" {: ".~"]} ".~"] [["" {: ".~"]} ".~"]]
    
  2. Il a été exécuté putsavec l'intention d'imprimer la pile encapsulée, suivi d'un saut de ligne.

    putsest défini comme {print n print}, il fait donc ce qui suit.

    1. printimprime la copie enveloppée de la pile sans l'inspecter (c'est-à-dire sans la convertir en sa représentation sous forme de chaîne). Cela envoie

      {: ".~"]}.~
      

      sur STDOUT et fait apparaître la copie de la pile du haut de la pile.

      La pile contient maintenant

      ["" {: ".~"]} ".~"]
      
    2. exécute le bloc de code que nous avons défini précédemment.

      :commence par enregistrer ["" {: ".~"]} ".~"]le caractère espace, puis se ".~"pousse et ]encapsule la pile dans un tableau.

    3. n pousse une chaîne composée d'un saut de ligne unique.

      La pile contient maintenant

      [["" {: ".~"]} ".~"] ".~"] "\n"
      
    4. est exécuté une fois de plus. Cependant, il a été redéfini lorsque nous l'avons appelé pour la première fois et contient maintenant un tableau, pas un bloc de code.

      En fait, il pousse ["" {: ".~"]} ".~"], laissant la pile

      [["" {: ".~"]} ".~"] ".~"] "\n" ["" {: ".~"]} ".~"]
      
    5. Enfin, printimprime l'élément de pile le plus haut sans l'inspecter, en envoyant

      {: ".~"]}.~
      

      à STDOUT.

Dennis
la source
1

𝔼𝕊𝕄𝕚𝕟, 26 caractères / 36 octets

⟮ô`\u27ee⦃ᶈ0}\u27ef
`ď2)⟯

Try it here (Firefox only).

Notez qu'il existe une nouvelle ligne de fin.

Explication

Quine standard: ⟮ⒸⅩ222+ᶈ0

Modifications:

  • Utilisez la ôfonction pour sortir les résultats de tous les résultats à la place du dernier résultat (comme pour la sortie implicite)
  • Utilisez \u27ee⦃ᶈ0}\u27ef\net fermez le bloc de copie pour éviter les conflits avec les blocs de copie ultérieurs.
  • Utilisez ď2pour répéter la chaîne deux fois.
Mama Fun Roll
la source