Faça um Quine.

Parece fácil, certo? Bem, esse quine deve produzir-se mais seu primeiro caractere, que depois se produz mais seu segundo caractere, e assim por diante.

Dessa maneira, o quine deve, em várias gerações, produzir duas cópias.

Exemplo: permite que seu código seja x. Executá-lo deve sair x + x[:1]. A execução do programa resultante deve produzir x + x[:2]e assim por diante ...

Se o seu código foi foobar, executando isso deve sair foobarf. Executando isso deve saída foobarfo. E assim por diante e assim por diante seguindo este padrão:

foobar
foobarf
foobarfo
foobarfoo
foobarfoob
foobarfooba
foobarfoobar
foobarfoobarf

Seu programa deve ter mais de 2 bytes e deve gerar apenas um caractere extra de seu próprio código a cada iteração.

Zsh ,110 108 100 bytes

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}

Experimente online!

Então é possível.

Explicação

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 bytes

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

crédito a este quine por inspiração. Funciona apenas se for executado no mesmo ambiente R que o quine anterior for executado.

Alice , 29 bytes

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

Experimente online!

O caractere não imprimível é 0x18.

Explicação

O problema com as "funções habituais do Fungeoid é que, se repetirmos o código fonte inteiro, também obteremos mais "e a string não cobre mais o código fonte inteiro. Suponho que é por isso que a resposta existente usa a gabordagem enganosa.

Essa resposta usa a "abordagem baseada em, mas em vez de incluir um "na fonte, nós a escrevemos no programa em tempo de execução. Dessa forma, haverá apenas um, "independentemente da frequência com que o programa é repetido (porque o gravamos apenas em uma coordenada específica, independentemente do tamanho do programa).

A ideia geral é criar uma representação de todo o código fonte na pilha, mas apenas percorrer os 29 primeiros caracteres (ou seja, o comprimento do programa) com o comprimento do loop determinado pelo tamanho do código. Portanto, podemos realmente acrescentar caracteres arbitrários (exceto feeds de linha) depois @e o resultado sempre será uma repetição cíclica do programa principal, um caractere mais longo que a 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 bytes (incluindo nova linha final)

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

Experimente online!

O bom __DATA__token antigo facilita o acréscimo de uma seqüência arbitrária a qualquer programa Perl, que o programa principal pode acessar por meio do <DATA>identificador de arquivo (e, na verdade __END__, usando o que faz a mesma coisa para compatibilidade com versões anteriores, em vez de __DATA__salvar dois bytes extras) .

Observe que este programa não lê seu próprio código-fonte, mas apenas os dados de entrada extras anexados à sua fonte após o __END__token. Com efeito, o __END__token e tudo o que vem depois funcionam como uma literal de sequência terminada no final da entrada.

Observe também que, para atender exatamente às especificações, esse programa deve terminar em uma nova linha. Caso contrário, a nova linha será anexada automaticamente após o segundo __END__, mas a primeira saída da iteração não será exatamente igual ao código mais o primeiro byte.

Befunge-98 , 30 bytes

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

Experimente online!

Minha tentativa de usar o Befunge-98, que usa um espaço terminado em quine, que também conta quantos caracteres foram produzidos. No entanto, usa o gcomando

PHP, 146 bytes

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);})?>

Deve ser executado usando -rna linha de comando.

Encantos Rúnicos , 61 bytes

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

Experimente online!

Usa uma abordagem semelhante à da resposta de Alice: escreve reflexivamente o "comando string no código, para que exista apenas um. Há muita manipulação de string e pilha para recuperar o programa original, quantos bytes extras são necessários e imprimir os blocos necessários.

A }͍sequência gira a representação da seqüência de caracteres na memória para que 803X4+kwapareça no início e não no final, devido à posição do "e não há uma maneira mais fácil de lidar com essa operação sem precisar calcular muitos números estranhos .

Enquanto o programa original é de 61 bytes, seu comprimento de cadeia é de apenas 50, o que é fácil de construir, 5Xe foi apenas coincidência que isso não precisou ser resolvido após conter toda a funcionalidade necessária (por exemplo, um programa de tamanho 49 seria mais fácil codificar como 50com um byte de preenchimento do que codificar um literal 49, enquanto 51seria codificado como 5X3+ou 53, tendo que levar em conta seus próprios bytes extras).