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.

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.

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

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!

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.

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!

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

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

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.

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