Il tuo compito è quello di scrivere un programma o una funzione che emetta il primo carattere del suo codice sorgente, quindi il secondo, quindi il terzo ... ogni volta che viene eseguito.

Ad esempio, se il tuo programma era foonella lingua barnel file baz.bar, dovresti ottenere un output simile a questo:

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

Il tuo programma può fare qualsiasi cosa una volta che ha finito di stampare il suo codice sorgente in questo modo. È possibile modificare il codice sorgente per il file, ma ricordare che il codice sorgente da stampare è il codice sorgente originale .

Questo è un codice-golf, quindi vince il programma più breve in byte.

Gelatina , 12 byte

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

Questo è un collegamento niladico. Provalo online! (Include il codice per chiamare il collegamento dodici volte.)

Come funziona

“;⁾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.

Come bonus aggiuntivo, poiché il registro conterrà una stringa vuota dopo la dodicesima chiamata, è di nuovo falsa e il collegamento è pronto per ricominciare. Chiamare il collegamento 24 volte produrrà il codice sorgente due volte, chiamandolo 36 volte tre volte, ecc.

Javascript - 26 byte

Definisce f()che restituisce il codice sorgente carattere per carattere.

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

Restituisce indefinito dopo aver esaurito i caratteri.

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

impilato , non competitivo, 34 byte

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

Una variazione sul quine standard. Questo è un programma completo. Questo utilizza execCounterper ottenere quante volte questo programma è stato eseguito specificamente. Errori dopo aver emesso tutto.

Provalo qui!

Pip , 31 byte

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

Una funzione anonima. Provalo su TIO!

Spiegazione

Inizia con questo Pip Quine standard:

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

Avvolgi questo tra parentesi graffe per renderlo una funzione. Ora, invece di restituire l'intera fonte, dobbiamo indicizzarla. L'uso di una variabile globale per l'indice e l'incremento ogni volta soddisfa il requisito "carattere successivo ogni volta che viene chiamato". vè il miglior candidato perché è preinizializzato -1. Incrementarlo la prima volta fornisce un indice di 0, la prossima volta 1, ecc.

Pip ha un indice ciclico, quindi una volta che la funzione stampa il suo ultimo carattere, ricomincia da capo.

Python, 90 byte

Un'estensione sullo standard Python quine (suggerimenti per il golf benvenuti):

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

Questa è una funzione del generatore python , il che significa che si esegue l'iterazione su di essa e ogni iterazione fornisce il carattere successivo nel codice sorgente. Quando tutti i personaggi sono stati restituiti, questo si blocca IndexError.

Per i test, aggiungi semplicemente questo script alla fine del programma:

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)

Oppure provalo online!

*> <> , 13 21 byte

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

Crea un file denominato \nper tenere traccia dell'indice.

Potrebbe essere possibile giocare a golf di più, ma nulla mi salta immediatamente fuori ...

Produzione

$ 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

Spiegazione

" 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

Chine Incremental Cheating

a1Fi1+:0go1F;

Spiegazione

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 byte

Commenti molto graditi; Sto ancora imparando le corde su ciò che le quine sono quine appropriate.

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

Definisce una funzione chiamata ripetutamente senza argomenti. Dopo la 91a chiamata, genera un grosso errore e restituisce un valore non valutato.

C'erano due problemi da superare: in primo luogo, volevo solo usare StringTake[ToString[#0]<>"[]"], ma ToString[]sembra cancellare le virgolette; così ho dovuto sostituire "[]"con FromCharacterCode[{91, 93}]. In secondo luogo, le variabili Mathematica iniziano non inizializzate, quindi non posso chiamare ++qprima che qsia definito; ecco perché If[!NumberQ[q], q = 0]è necessaria l'iniziale .

Coda irrilevante: guardando in alto NumberQ, ho imparato che Mathematica ha una funzione chiamata TrueQ... che, sì, restituisce Truese l'argomento è Truee Falsese l'argomento è False! (L'utilità è che ritorna anche Falsesu tutti gli altri argomenti.)

Microscript II, 40 33 byte

Un blocco di codice letterale, l'equivalente più vicino alla lingua di una funzione:

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

Dopo l'esecuzione, si reinserisce xper rendere più facile richiamare nuovamente.

Bash (e zsh, ksh), 39 byte

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

Non stampa nulla dopo che il programma è stato stampato.

Assicurarsi 0che non esista nella directory corrente ed eseguire:

bash iquine.bash