Incrémental Quine

23

Votre tâche consiste à écrire un programme ou une fonction qui génère le premier caractère de son code source, puis le second, puis le troisième ... à chaque exécution.

Par exemple, si votre programme était foodans la langue bardu fichier baz.bar, vous devriez obtenir une sortie similaire à ceci:

λ bar baz.bar
f
λ bar baz.bar
o
λ bar baz.bar
o

Votre programme peut faire n'importe quoi une fois qu'il a fini d'imprimer son code source de cette façon. Vous pouvez modifier le code source du fichier, mais n'oubliez pas que le code source à imprimer est le code source d' origine .

Il s'agit d'un code-golf, donc le programme le plus court en octets l'emporte.

Conor O'Brien
la source
1
Si nous pouvons modifier le code source du fichier, cela signifie-t-il que nous pouvons également le lire?
FlipTack
1
@ Flp.Tkc Bonne question. Honnêtement, je n'en ai aucune idée. Je ne veux pas que vous construisiez le quine en lisant la source, mais je suis d'accord si vous lisez la source pour la modification du fichier uniquement.
Conor O'Brien

Réponses:

6

Gelée , 12 octets

“;⁾vṾ®ȯ©Ḣ”vṾ

Ceci est un lien niladique. Essayez-le en ligne! (Comprend le code pour appeler le lien douze fois.)

Comment ça marche

“;⁾vṾ®ȯ©Ḣ”vṾ  Niladic link.

“;⁾vṾ®ȯ©Ḣ”    Set the left argument and the return value to s =: ';⁾vṾ®ȯ©Ḣ'.
           Ṿ  Uneval; yield r =: '“;⁾vṾ®ȯ©Ḣ”', a string representation of s.
          v   Eval; execute s as a Jelly program with argument r.

 ⁾vV          Yield 'vṾ'.
;             Concatenate r and 'vṾ', yielding q =: '“;⁾vṾ®ȯ©Ḣ”vṾ'.
    ®ȯ        Take the flat logical OR of the register (initially 0) and q.
              This replaces 0 with q in the first run, but it will yield the
              content of the register in subsequent runs.
      ©       Copy the result to the register.
       Ḣ      Head; pop and yield the first character of the register.
              This modifies the string in the register, so it holds one fewer
              character after each call.

Comme bonus supplémentaire, puisque le registre contiendra une chaîne vide après le douzième appel, il est à nouveau faux et le lien est prêt à recommencer. Appeler le lien 24 fois affichera le code source deux fois, en l'appelant 36 fois trois fois, etc.

Dennis
la source
Je ne connais pas Jelly, alors que fait exactement le pied de page? Pourquoi ^ 17?
Conor O'Brien
Appelez le lien ci-dessus ( ¢), fonction d'identité ( ¹, pas vraiment nécessaire après le premier appel), définissez la valeur de retour sur saut de ligne ( , imprime implicitement la valeur de retour précédente), répétez. ¹et sont tous deux des exposants, mais ils ne sont pas liés. Je les ai remplacés par les moins déroutants ¢;¢;¢;¢;¢;¢;¢;¢;¢;¢;¢;¢(appeler, concaténer, répéter).
Dennis
12

Javascript - 26 octets

Définit f()qui renvoie le code source caractère par caractère.

n=0;f=x=>("n=0;f="+f)[n++]

Renvoie undefined après qu'il manque de caractères.

n=0;f=x=>("n=0;f="+f)[n++]
for(i=0;i<30;i++){console.log(f())} //test harness

Maltysen
la source
Si je ne me trompe pas, vous devez inclure l'appel de fonction dans le code.
Mama Fun Roll
@MamaFunRoll lien vers le meta post pertinent?
Downgoat
Je n'en connais aucun: P Cependant, j'ai toujours pensé que l'appel de fonction lui-même faisait partie du quine; peut-être qu'il me manque quelque chose?
Mama Fun Roll
@MamaFunRoll La spécification autorise spécifiquement les fonctions, donc un appel ne devrait pas être nécessaire. De toute façon, cela n'aurait pas beaucoup de sens pour ce défi particulier.
Dennis
Très bien, juste pour être sûr.
Mama Fun Roll
2

empilées , non concurrentes, 34 octets

[tostr ':!' + execCounter # out]:!

Une variation sur le quine standard. Ceci est un programme complet. Cela permet execCounterd'obtenir combien de fois ce programme a été spécifiquement exécuté. Erreurs après avoir tout sorti.

Essayez-le ici!

Conor O'Brien
la source
2

Pip , 31 octets

{Y"{Y (yRsRPy++v)}"(yRsRPy++v)}

Une fonction anonyme. Testez-le sur TIO!

Explication

Commencez avec cette quine standard Pip:

Y"Y yRsRPy"yRsRPy
Y"Y yRsRPy"        Yank that string into y
           yRsRPy  In y, replace the space with repr(y)

Enveloppez-le entre accolades pour en faire une fonction. Maintenant, au lieu de renvoyer la source entière, nous devons l'indexer. Utiliser une variable globale pour l'index et l'incrémenter à chaque fois remplira l'exigence "caractère suivant à chaque fois qu'il est appelé". vest le meilleur candidat car il est préinitialisé à -1. L'incrémenter la première fois donne un indice de 0, la prochaine fois 1, etc.

Pip a une indexation cyclique, donc une fois que la fonction imprime son dernier caractère, elle recommencera au début.

DLosc
la source
1

Python, 90 octets

Une extension sur le quine Python standard (conseils de golf bienvenus):

def f(n=0,s='def f(n=0,s=%r):\n while 1:yield(s%%s)[n];n+=1'):
 while 1:yield(s%s)[n];n+=1

Il s'agit d'une fonction de générateur python , ce qui signifie que vous itérez dessus, et chaque itération fournit le caractère suivant dans le code source. Lorsque tous les personnages ont été retournés, cela se bloque avec IndexError.

Pour les tests, ajoutez simplement ce script à la fin du programme:

source = ''
try:
    # Call generator, add characters to the string
    for char in f():
        source += char
except IndexError:
    # Generator has reached end of source code
    pass

print(source)

Ou essayez-le en ligne!

FlipTack
la source
1

*> <> , 13 21 octets

" r:2+a1Fi1+:1F1+[ro;

Crée un fichier nommé \npour garder une trace de l'index.

Cela peut être plus jouable au golf, mais rien ne me saute immédiatement aux yeux ...

Sortie

$ starfish incrementalquine.sf 
"$ starfish incrementalquine.sf 
 $ starfish incrementalquine.sf 
r$ starfish incrementalquine.sf 
:$ starfish incrementalquine.sf 
2$ starfish incrementalquine.sf 
+$ starfish incrementalquine.sf 
a$ starfish incrementalquine.sf 
1$ starfish incrementalquine.sf 
F$ starfish incrementalquine.sf 
i$ starfish incrementalquine.sf 
1$ starfish incrementalquine.sf 
+$ starfish incrementalquine.sf 
:$ starfish incrementalquine.sf 
1$ starfish incrementalquine.sf 
F$ starfish incrementalquine.sf 
1$ starfish incrementalquine.sf 
+$ starfish incrementalquine.sf 
[$ starfish incrementalquine.sf 
r$ starfish incrementalquine.sf 
o$ starfish incrementalquine.sf 
;$ starfish incrementalquine.sf

Explication

" r:2+                 build the quine
      a1F              open file named "\n"
         i1+:          read input, increment by 1, duplicate
             1F        save incremented input to file
               1+[     increment input, copy that many values to a new stack
                  ro   output the character at the beginning of the new stack
                    ;  end

Tricher Incrineal Quine

a1Fi1+:0go1F;

Explication

a1F            open file named "\n"
   i1+         read input and add 1 to it
      :0g      push the value at (input,0) to the stack
         o     output the value
          1F   save the incremented input to the file
            ;  exit
redstarcoder
la source
haha, je ne savais pas que vous pouviez nommer un fichier "\ n". Bien que cela lit techniquement le code source, par l' ginstruction.
Conor O'Brien
@ ConorO'Brien, ah assez juste. hmm ...
redstarcoder
*> <> A-t-il une sorte d'indexation de pile? Ou commander la répétition? Ensuite, vous pouvez utiliser le framework de quine standard "your code goes here;pour> <>, puis accéder au nième membre de la pile
Conor O'Brien
@ ConorO'Brien ouais Teal Pelican m'a montré cette variante quine sur mon autre réponse quine tricherie :).
redstarcoder
1
@redstarcoder J'ai travaillé plus sur les quines (YAY!) et j'ai trouvé une bonne astuce, si vous remplacez r par #, vous pouvez: 1- le # comme; #; ou [+ 1F1: + 1iF1a-1: "Je ne peux pas tester ceci pour le moment mais je crois que cela coupe 1 octet de votre code.> <> les quines peuvent être faites comme #o <-1:" etc: D
Pélican bleu canard
1

Mathematica, 91 octets

Commentaires très bienvenus; J'apprends encore les ficelles de ce que sont les quines appropriées.

(If[!NumberQ[q], q = 0]; StringTake[ToString[#0]<>FromCharacterCode[{91, 93}], {++q}]) & []

Définit une fonction appelée à plusieurs reprises sans arguments. Après le 91e appel, il lance une grosse erreur et revient sans évaluation.

Il y avait deux problèmes à surmonter: d'abord, je voulais juste utiliser StringTake[ToString[#0]<>"[]"], mais ToString[]semble effacer les guillemets; j'ai donc dû remplacer "[]"par FromCharacterCode[{91, 93}]. Deuxièmement, les variables Mathematica commencent non initialisées, donc je ne peux pas appeler ++qavant qest défini; c'est pourquoi l'initiale If[!NumberQ[q], q = 0]est nécessaire.

Coda non pertinente: en levant les yeux NumberQ, j'ai appris que Mathematica a une fonction appelée TrueQ... qui, oui, retourne Truesi l'argument est Trueet Falsesi l'argument l'est False! (L'utilité est qu'il renvoie également Falsetous les autres arguments.)

Greg Martin
la source
1

Microscript II, 40 33 octets

Un littéral de bloc de code, l'équivalent le plus proche du langage d'une fonction:

{ss1K+>K>s#<v{o}sl*v!(123v)lKp<o}

Après l'exécution, il se remet en place xpour faciliter l'invocation à nouveau.

SuperJedi224
la source
0

Bash (et zsh, ksh), 39 octets

a=`<$0`;pwd>>0;echo ${a:`wc -l<0`-1:1}

Il n'imprime rien après l'impression du programme.

Assurez 0- vous qu'il n'existe pas dans le répertoire en cours et exécutez:

bash iquine.bash
Kaito Udagawa
la source
Bienvenue chez PPCG! Vous avez une idée intelligente pour incrémenter l'index. Malheureusement, il semble que cette réponse fonctionne en lisant son propre code source, ce qui signifie que ce n'est pas un quine valide selon nos normes . Si vous le modifiez pour utiliser des techniques de quine autres que la lecture de sa propre source, ce sera une bonne réponse.
DLosc