Escreva um programa (ou função) (vamos chamá-lo de P1) que, quando executado, gera outro programa P2 do mesmo idioma e exatamente 1 byte a mais que P1.

O programa P2, quando executado, deve produzir um terceiro programa P3 com 1 byte a mais que P2. P3 deve emitir um programa P4 com um byte mais longo que P3, etc. O mesmo para P5, P6, ..., P∞.

A cadeia de programas deve ir indefinidamente ou para um local onde o intérprete não aguenta mais (mas deve permanecer como um programa teoricamente válido no idioma)

Regras

• Lacunas padrão proibidas
• Todos os programas da cadeia devem estar em um idioma
• Nenhuma entrada é fornecida. A saída vai para stdout ou valor de retorno da função
• O programa deve terminar após um período de tempo. Um programa que para de gerar saída após um determinado período de tempo, mas nunca termina, não se qualifica

O programa mais curto P1 em bytes em cada idioma vence!

JavaScript (ES6), 14 12 bytes

-2 bytes graças a @Shaggy

f=_=>"f=_"+f

Snippet de teste

s=`f=_=>"f=_"+f`;

for(i=10;i--;s=eval(s)())
  o.innerText+=s+"\n";

<pre id=o></pre>

7 , 4 bytes de ASCII

1603

Experimente online!

Eu sei que 7 normalmente não é codificado em ASCII, mas desta vez é uma codificação mais conveniente, de modo que adicionamos 1 byte a cada execução, não 3 bits.

Também não tenho certeza se isso conta como trapaça ou não. (Geralmente, não está claro se um quine 7 está trapaceando ou não, pois ele se estende pela fronteira de várias maneiras.) Você pode argumentar decentemente que o 0código é codificado 6, mas, em geral, não está claro de onde vêm os caracteres resultantes " "em 7 porque possui muitos comportamentos implícitos, bastante bizarros.

Este programa imprime-se com 1anexado e o fará mesmo se você anexar um número de 1s. Aqui está um rastreamento de depuração comentado de 160311:

|| 160311      Initial data ||; initial program 160311
||7 60311      1 command = append 7 to data
|1 0311        6 command = escape from the last | onwards (7 escapes to 1)
|16e77         0311 commands = append 6e77 to data
|16e77 16e77   Implicit (program is empty): copy data past last | to program
|16e777 6e77   1 command = append 7 to data
71603111 e77   6 command = escape from the last | onwards
71603111 e77   e7 command = output in same encoding as the source

(Não há mais |no programa, o encerramento eserá imediato como um efeito colateral, o que significa que os resultados finais 7nunca serão executados).

A confusão básica sobre a origem de todos os caracteres é que a maioria dos comandos no 7 apenas produz dados quando executados e, em seguida, 6tenta reconstruir uma sequência de comandos que produziria o fragmento de dados fornecido; isso geralmente acaba próximo, mas não é idêntico, ao original. (Para fins quining, você normalmente escrever um programa de 7 de tal modo a que o resultado será quase o mesmo, normalmente diferindo na esquerda ou à direita 7s.) Assim, por exemplo, a 1nos dados torna-se 716, que é a maneira mais fácil de anexar 1para a cadeia de dados atual. Nós o produzimos originalmente com 16uma sequência de caracteres diferente (mas semelhante), removendo destrutivamente um dos|marcadores com os quais os dados começaram. (Acho que talvez o melhor argumento de que essa não seja uma solução literal apenas seja que a saída seja diferente da entrada!)

Haskell , 74 66 bytes

EDITAR:

• -2 bytes por H.PWiz usando <>, depois -6 movendo o (10*)<$>.

Agora, ele usa o <>operador recém-livre ( Semigroupmultiplicação, requer que o GHC 8.4 funcione sem importação).

main=putStr$fst<>show$(10*)<$>("main=putStr$fst<>show$(10*)<$>",1)

Experimente online! (Truques com uma importação, pois o TIO ainda não possui GHC 8.4.)

Como funciona

• main=putStr$ é clichê para gerar o seguinte valor de sequência.

• fst<>showé uma função que pega uma tupla e retorna uma string que consiste no primeiro elemento da tupla concatenado com a representação da string da tupla. Ou seja,

  (fst<>show)(s,t) = fst(s,t)<>show(s,t) = s++show(s,t)

• (10*)<$>multiplica o último elemento da tupla a seguir por 10, adicionando um dígito 0à sua representação de sequência.

C (gcc) , 134 132 bytes

Ligeiro retrabalho da canina C quine. Terrivelmente longo.

x;*s="x;*s=%c%s%c;main(i){for(i=__LINE__;i--;puts(&x));printf(s,34,s,34);}";main(i){for(i=__LINE__;i--;puts(&x));printf(s,34,s,34);}

Experimente online!

Fissão 2 , 7 bytes

'!+OR!"

Experimente online!

O padrão Fission quine , mas com um extra !que imprime um 0x01 adicional no início do código em cada iteração.

Pari / GP , 35 bytes

(f=(x)->print1("(f="f")("1x")"))(1)

Experimente online!

Python 2 , 38 bytes

s="print's=%r;exec s'%(s+'#')";exec s

Experimente online!

brainfuck , 420 bytes

->+++>>+++>+>++>+++>+>+>+++>>>>>>>>>>>>>>>>>>>>+>+>++>+++>++>>+++>+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+>+>>+++>>+++>>>>>+++>+>>>>>>>>>++>+++>+++>+>>+++>+++>+>++>>+++>+>+++>+>++>+++>>>+>+>++>+++>+>+>>+++>>>>>>>+>+>>>+>+>++>+++>+++>+>>+++>>>+++>+>++>+++>++>>+>+>++>+++>+>+>>+++>>>>>+++>+>>>>>++>+++>+++>+>>+++>>>+++>+>+++>+>>+++>>+++>>++[[>>+[>]++>++[<]<-]>+[>]<+<+++[<]<+]>>->[>]++++>++[[<++++++++++++++++>-]<+++++++++.<]>.

Experimente online!

Esta é uma modificação no quine BrainFuck "padrão" , com um .no final que adere a .cada iteração extra .

O quine em si codifica caracteres Brainfuck como uma pilha de dígitos hexadecimais: especificamente, os dígitos hexadecimais de c-0x2b, que são convenientemente os seguintes:

+: 0x00
-: 0x02
[: 0x30
]: 0x32
<: 0x11
>: 0x13
,: 0x01
.: 0x03

A codificação abrange dois trechos de código: >++[[>>+[>]++>++[<]<-]>+[>]<+<+++[<]<+]>>->[>]++++>++empurra a codificação da própria codificação, [[<++++++++++++++++>-]<+++++++++.<]percorre a pilha e imprime tudo.

Sujo , 9 bytes

'"n[!]a!␛

Experimente online!

'   start and end a string literal
"   push a literal '
n   remove newlines
[!] print the string
a   push the alphabet
!   print the first character
␛   end the program

Se a leitura do código-fonte for permitida:

Sujo , 8 bytes

Q[!]W33!

Experimente online!

Explicado:

Q   push the source code
[!] print each character
W   clear the now-empty stack
33! print an exclaimation mark

Pode ser válido:

Sujo , 4 bytes

Q[‼]

Experimente online!

Ele imprime o código-fonte com uma nova linha à direita.
(E vários espaços, devido a um bug. Porém, funciona da mesma forma sem eles.)

Observe que ele só funciona no conjunto de caracteres nativo, e não quando você usa o front-end UTF8 - para experimentá-lo no TIO, é necessário substituir o caractere que ele gera entre []s ‼, que é o equivalente UTF8 para o que está imprimindo .

Java 8, 162 146 bytes

v->{String s="v->{String s=%c%s%1$c+1;return s.format(s,34,s).replaceAll(%1$c1+$%1$c,%1$c%1$c);}"+1;return s.format(s,34,s).replaceAll("1+$","");}

Experimente online.
Experimente o primeiro programa de saída ; Tente o segundo programa de saída ; Experimente o terceiro programa de saída .

Explicação:

v->{                       // Method with empty unused parameter and String return-type
  String s="v->{String s=%c%s%1$c+1;return s.format(s,34,s).replaceAll(%1$c1+$%1$c,%1$c%1$c);}"
                           //  The unformatted source code
           +1;             //  Plus a random digit (1 in this case)
  return s.format(s,34,s)  //  Create the quine
          .replaceAll("1+$","");}
                           //  Then remove any trailing 1s

quine -part:

• O String scontém o código fonte não formatado.
• %sé usado para inserir esta String em si mesma com o s.format(...).
• %c, %1$cE 34são usados para formatar as aspas.
• s.format(s,34,s) coloca tudo junto

Parte do desafio:

• +1 adiciona um 1 ao programa não formatado e formatado.
• .replaceAll("1+$","");}: Como queremos aumentar apenas a contagem de bytes do programa em um em vez de dois, removemos 1s à direita antes de retornar.

> <> , 9 bytes

#o<:}-1:"

Experimente online!

Variação em uma quine clássica> <>, que simplesmente adiciona outro comando dupe para copiar #na frente.

Perl 5 , 32 bytes

$_=q{say"\$_=q{$_
};eval"};eval

Experimente online!

GolfScript , 9 bytes

{'.~1'}.~

Experimente online!

CJam , 9 bytes

{"_~1"}_~

Experimente online!

Estou postando essas duas soluções na mesma resposta, pois são apenas variações triviais uma da outra e funcionam exatamente da mesma maneira. Ambos são baseados no quine comum do GolfScript {'.~'}.~(ou {"_~"}_~no CJam), que é descrito em mais detalhes, por exemplo, nesta resposta anterior.

A única diferença é que essa variante acrescenta um 1byte ao final de sua saída. Por acaso, qualquer sequência de 1s (ou qualquer outro literal inteiro sem zeros à esquerda) é uma solução trivial no GolfScript e no CJam; portanto, qualquer uma que já esteja presente no final do código acima será simplesmente copiada literalmente para a saída. Como o GolfScript (e o CJam) usam números inteiros de comprimento arbitrário, isso funcionará para programas arbitrariamente longos, pelo menos enquanto o computador executando o código tiver memória suficiente para armazená-lo.

Anexo , 76 72 61 bytes

Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]]",Repr[x+sp]]

Experimente online!

Quine padrão que adiciona um espaço ao final de xcada iteração.

Primeiras iterações:

Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]]",Repr[x+sp]]

Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]] ",Repr[x+sp]]

Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]]  ",Repr[x+sp]]

etc.

Anexo, 72 bytes

y:=1Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]

Experimente online!

Isso é simplesmente uma variação do formato padrão quine, com uma variável yconfigurada para 10*yapós cada iteração

As primeiras iterações:

y:=1Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]

y:=10Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]

y:=100Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]

etc.

Swift 4 , 89 bytes

let(a,b)=(";print(\"let(a,b)=\\((a,b+\"-\"))\"+a)", "");print("let(a,b)=\((a,b+"-"))"+a)

Inclui uma nova linha à direita

Experimente online!

Haskell , 88 bytes

main=putStr$snd(span(<'m')s)++show s;s='#':"main=putStr$snd(span(<'m')s)++show s;s='#':"

Experimente online! Cresce anexando #à sequência de dados.

Stax , 20 18 bytes

"34s+cTZL"34s+cTZL

Execute e depure

Gera um espaço extra antes da 2ª aspas a cada iteração.

Explicação

Usa o programa "34s+cTZL "34s+cTZLpara explicar.

"34s+cTZL "34s+cTZL
"34s+cTZL "            String literal
           34s+        Prepend a double quote, Now the string is `"34s+cTZL `
               cT      Copy and trim trailing spaces
                 Z     Put a 0 under the top of stack
                       Stack now (from top to bottom): `["34s+cTZL,0,"34s+cTZL ]`
                  L    Collect all elements on stack, from bottom to top
                       Implicit output, 0 is converted to space.

Jstx , 4 bytes

£↕♣:

Experimente online!

Encantos Rúnicos , 6 bytes

"'<S@>

Experimente online!

Este foi estranho. Tudo o que eu tinha que fazer era remover uma ~das amostras originais encontradas por Jo King .

Cada execução adicional acrescenta outra <ao final, por exemplo:

"'<S@><<<<<<<<<

Todos os quais não fazem nada.

Cópia direta desta resposta em um desafio relacionado. Aconteceu que ele já cresceu 1 byte a cada iteração (o argumento forte para esse desafio é uma duplicata desse ou vice-versa).

Gelatina , 11 bytes

“⁾;⁶;ØV” ṘV

Experimente online!

Maravilha , 33 bytes

f\ @(-> ol) ["f\ ";f;";f1";#0];f1

Uma variante interessante no quine normal que acrescenta 1 após cada iteração.

Progressão:

f\ @(-> ol) ["f\ ";f;";f1";#0];f1
f\ @(-> ol) ["f\ ";f;";f1";#0];f11
f\ @(-> ol) ["f\ ";f;";f1";#0];f111
...

Explicação

f\ @                               #. Sets f to a function that does the following:
    (-> ol) [                      #.   Output each:
             "f\ ";                #.     String for declaration of f
                   f;              #.     Formatted representation of f's function
                     ";f1";        #.     String for call of f
                           #0      #.     Argument passed into f
                             ];f1  #. Call f with 1 as the argument

Uma das partes interessantes desse quine é que o Wonder pode trabalhar com números de precisão arbitrária, de modo que a progressão não será interrompida após um certo número de unidades.

ColdFusion, 277 bytes

<cfset u=Chr(34)><cfset q="<cfset u=Chr(34)><cfset q=%s%s%s><cfoutput>%screateObject(%sjava%s,%sjava.lang.String%s).format(q,[u,q,u,Chr(35),u,u,u,u,Chr(35)])%s</cfoutput>
"><cfoutput>#createObject("java","java.lang.String").format(q,[u,q,u,Chr(35),u,u,u,u,Chr(35)])#</cfoutput>

Essa é uma modificação trivial do meu quine do ColdFusion, que adiciona uma nova linha a cada vez que é chamada.

Testado localmente em lucee-express-5.2.6.60

Lote do Windows, 38 36 bytes

echo|set/p"=q">q&copy/b/y %0+q %0
::

Esse código cria um arquivo chamado "q", contendo a letra 'q' e, em seguida, o anexa ao arquivo original. Observe que "::" é um alias para "rem" que não requer um espaço adicional.

Economizou 2 bytes graças ao user3493001.

Gol> <> , 7 bytes

":r2ssH

Experimente online! Experimente online !! Experimente online !!!

Essa é uma variação simples da rotina Gol> <> normal, mas adiciona uma cópia de Hcada vez que é executada. Como o Hcomando interrompe o programa, adicional Hno final não altera o comportamento.

T-SQL , 175 bytes

DECLARE @ VARCHAR(MAX)='DECLARE @ VARCHAR(MAX)=*SET @=TRIM(REPLACE(@,0x2a,CHAR(39)+@+CHAR(32)+CHAR(39)))PRINT @'SET @=TRIM(REPLACE(@,0x2a,CHAR(39)+@+CHAR(32)+CHAR(39)))PRINT @

Primeiro, escrevi um SQL quine, depois o modifiquei para adicionar um espaço extra (um pouco inspirado por esta resposta ).

Befunge-98 (PyFunge) , 22 19 bytes

r:#,_ #;'D2/'<,,@;"

Experimente online!

Adiciona um <antes da última "a cada geração.

C # (compilador interativo do Visual C #) , 89 bytes

var s="var s={0}{1}{0}+8;Write(s.Trim('8'),(char)34,s);"+8;Write(s.Trim('8'),(char)34,s);

Inspirado pela resposta de Kevin Cruijssen.

Experimente online!