Fai un Quine.

Sembra facile vero? Bene, questo quine deve generare se stesso più il suo primo carattere, che quindi genera se stesso più il suo secondo carattere, e così via.

In questo modo le quine dovrebbero produrre in due generazioni due copie.

Esempio: consente di inserire il codice x. Eseguendolo dovrebbe emettere x + x[:1]. L'esecuzione del programma risultante dovrebbe generare x + x[:2]e così via ...

Se il tuo codice era foobar, in esecuzione questo dovrebbe produrre foobarf. In esecuzione questo dovrebbe produrre foobarfo. E così via e così via seguendo questo schema:

foobar
foobarf
foobarfo
foobarfoo
foobarfoob
foobarfooba
foobarfoobar
foobarfoobarf

Il tuo programma deve essere più lungo di 2 byte e deve emettere solo UN carattere aggiuntivo del proprio codice ogni iterazione.

Zsh ,110 108 100 byte

a=`<&0`<<''<<<t;b=${a:0:50};printf $b$b${a:0:-50}
a=`<&0`<<''<<<t;b=${a:0:50};printf $b$b${a:0:-50}

Provalo online!

Quindi è possibile

Spiegazione

a=`<&0`<<''<<<t;       # Set A to everything following this line, until eof or
                       #   an empty line (which never happens before eof) encountered.
                       # A "t" is appended to prevent automatic trimming of newlines.
b=${a:0:50};           # Set B to the first line.
printf $b$b${a:0:-50}  # Print two copies of B and
                       #   A with 50 trailing characters removed.

R, 289 byte

s<-c("s<-", "i=get0('i',ifnotfound=0)+1;p=paste0(s,substr(get0('p',ifnotfound=s),1,i),collapse='');cat(s[1]);dput(s);cat(paste0(s[2],substr(p,1,i)))#")
i=get0('i',ifnotfound=0)+1;p=paste0(s,substr(get0('p',ifnotfound=s),1,i),collapse='');cat(s[1]);dput(s);cat(paste0(s[2],substr(p,1,i)))#

merito a questo quine per l'ispirazione. Funziona solo se eseguito nello stesso ambiente R del precedente quine.

Alice , 29 byte

4P.a+80pa2*&wdt,kd&w74*,.ok@

Provalo online!

Il carattere non stampabile è 0x18.

Spiegazione

Il problema con le solite "quine Fungeoid basate su è che se ripetiamo l'intero codice sorgente, otteniamo anche ulteriori "e la stringa non copre più l'intero codice sorgente. Suppongo sia per questo che la risposta esistente usi ginvece l'approccio cheat-y .

Questa risposta usa l' "approccio basato su, ma invece di includere un "nel sorgente, lo scriviamo nel programma in fase di esecuzione. In questo modo, ce ne sarà sempre uno "indipendentemente dalla frequenza con cui il programma viene ripetuto (perché lo scriviamo solo su una coordinata specifica, indipendentemente dalle dimensioni del programma).

L'idea generale è quindi quella di creare una rappresentazione dell'intero codice sorgente nello stack, ma scorrere solo i primi 29 caratteri (ovvero la lunghezza del programma) con la lunghezza del ciclo determinata dalla dimensione del codice. Pertanto, possiamo effettivamente aggiungere caratteri arbitrari (eccetto gli avanzamenti di riga) dopo @e il risultato sarà sempre una ripetizione ciclica del programma principale, un carattere più lungo della fonte.

4P   Push 4! = 24. This is the code point of the unprintable, which we're 
     using as a placeholder for the quote.
.a+  Duplicate it and add 10, to get 34 = '"'.
80p  Write '"' to cell (8,0), i.e. where the first unprintable is.
    Placeholder, becomes " by the time we get here, and pushes the code
     points of the entire program to the stack. However, since we're already
     a good bit into the program, the order will be messed up: the bottom
     of the stack starts at the 24 (the unprintable) followed by all 
     characters after it (including those from extraneous repetitions). Then 
     on top we have the characters that come in front of the `"`. 
     So if the initial program has structure AB, then any valid program has
     the form ABC (where C is a cyclic repetition of the initial program),
     and the stack ends up holding BCA. We don't care about C, except to
     determine how big the program is. So the first thing we need to do is
     bring B to the top, so that we've got the initial program on top of
     the stack:
a2*  Push 10*2 = 20.
&w   Run the following section 21 times, which is the length of B.

  dt,  Pull up the value at the bottom of the stack.

k    End of loop.
d&w  Run the following section D+1 times, where D is the length of ABC.

  74*  Push 28, one less than the number of characters in AB.
  ,    Pull up the 29th stack element, which is the next character to print.
  .o   Print a copy of that character.

k    End of loop.
@    Terminate the program.

Perl 5 , 83 byte (inclusa la nuova riga finale)

$_=q($/=$;;$_="\$_=q($_);eval
__END__
".<DATA>;print$_,/(.).{82}\z/s);eval
__END__

Provalo online!

Il buon vecchio __DATA__token semplifica l'aggiunta di una stringa arbitraria a qualsiasi programma Perl, al quale il programma principale può quindi accedere tramite l' <DATA>handle del file (e in realtà utilizzando __END__, che fa la stessa cosa per la compatibilità all'indietro, invece di __DATA__salvare due byte extra) .

Si noti che questo programma non legge il proprio codice sorgente, ma solo i dati di input aggiuntivi aggiunti alla sua fonte dopo il __END__token. In effetti, il __END__token e tutto ciò che segue funziona in un certo senso come una stringa letterale terminata dalla fine dell'input.

Inoltre, per soddisfare esattamente le specifiche, questo programma deve terminare con una nuova riga. In caso contrario, la nuova riga viene effettivamente aggiunta automaticamente dopo la seconda __END__, ma la prima uscita di iterazione non sarà più esattamente uguale al codice più il suo primo byte.

Befunge-98 , 30 byte

0>:#;0g:840#;+*#1-#,_$a3*%0g,@

Provalo online!

Provo a usare Befunge-98 che usa uno spazio chiuso terminato con spazio che conta anche quanti caratteri sono stati emessi. Tuttavia utilizza il gcomando.

PHP, 146 byte

ob_start(function($s){return($u=substr($s,0,73)).$u.substr($s,0,-72);})?>ob_start(function($s){return($u=substr($s,0,73)).$u.substr($s,0,-72);})?>

Dovrebbe essere eseguito utilizzando -rnella riga di comando.

Incantesimi runici , 61 byte

803X4+kw.'.q}͍}͍}͍}͍}͍}͍}͍}͍}͍::l͍5X-:}-$:l͍{-1--@

Provalo online!

Utilizza un approccio simile alla risposta di Alice: scrive in modo riflessivo il "comando stringa nel codice in modo che Esista solo uno. Ci sono molte manipolazioni di stringhe e stack per ripristinare il programma originale, quanti byte extra sono necessari e stampare gli hunk necessari.

La }͍sequenza ruota attorno alla rappresentazione della stringa in memoria in modo che 803X4+kwappaia all'inizio anziché alla fine, a causa della posizione di "e non esiste un modo più semplice di gestire questa operazione senza dover calcolare molti numeri scomodi .

Mentre il programma originale è di 61 byte, la sua lunghezza della stringa è solo 50, il che è facile da costruire come 5Xed era solo una coincidenza che questo non avesse bisogno di essere riempito dopo aver contenuto tutte le funzionalità necessarie (ad esempio un programma di lunghezza 49 sarebbe più facile codificare come 50con un byte di padding che codificare un letterale 49, mentre 51sarebbe codificato come 5X3+o 53, dovendo tenere conto dei propri byte extra).