Você deve escrever um programa que produzirá o código fonte que é

1. Maior que o programa original (em termos de caracteres)
2. Irá imprimir outro programa maior que ele quando executado (ou seja, o novo programa também é uma resposta válida para esse desafio)

Isso é código-golfe, então a resposta mais curta vence.

GS2 (8636 esposa) , 0 bytes

Isso imprime uma única nova linha, que imprime duas novas linhas, que imprime três novas linhas, etc.

Experimente online!

H9 + : 1 caracter

9

Está certo. Um personagem. Produz a letra para 99 garrafas de cerveja , que é um programa válido. Todos os dados estranhos não contam, mas há muitos 9s nele.

A saída do programa produzido é a letra de 99 garrafas de cerveja 59 vezes.

Esta função fornece o número de vezes que as letras são exibidas se você executar os ntempos do programa (se meu cálculo estiver correto):

f(n) = 59n-1

GolfScript, 9 caracteres

{.'.~'}.~

Este código gera:

{.'.~'}{.'.~'}.~

quais saídas:

{.'.~'}{.'.~'}{.'.~'}.~

quais saídas:

{.'.~'}{.'.~'}{.'.~'}{.'.~'}.~

e assim por diante.

Acredito que esta seja a resposta mais curta em uma linguagem de programação "real" completa de Turing até agora.

Explicação:

Basicamente, o código original acima é uma "camada de quine": ele gera uma quine normal seguida por ela mesma.

No GolfScript, qualquer literal de bloco de código (por exemplo {foo}), se não for perturbado na pilha, é uma solução. Assim, por si só, {.'.~'}simplesmente se produz, como qualquer outro bloco de código.

O .~no final do código pega o último bloco de código na pilha, duplica e executa a cópia. Quando executado, o código .'.~'dentro do bloco de código duplica o item mais alto da pilha (isto é, a cópia de si mesmo) e anexa a string .~.

No final do programa, o intérprete GolfScript codifica e gera tudo na pilha, que, nesse caso, consiste em mais um {.'.~'}bloco do que na entrada, mais a string .~.

Bônus:

Adicionar um ]antes do primeiro .(para coletar todos os blocos de código na pilha em uma matriz antes de serem duplicados) faz com que cresça exponencialmente:

{].'.~'}.~

saídas:

{].'.~'}{].'.~'}.~

quais saídas:

{].'.~'}{].'.~'}{].'.~'}{].'.~'}.~

quais saídas:

{].'.~'}{].'.~'}{].'.~'}{].'.~'}{].'.~'}{].'.~'}{].'.~'}{].'.~'}.~

e assim por diante.

Caracteres Java 7: 0

Salve como arquivo Blank.java. Se você salvá-lo como qualquer outro arquivo, substitua qualquer instância de Blankpelo nome do arquivo apropriado.

Em seguida, execute na linha de comandos, primeiro compilando e depois executando. Se a compilação falhar, pare.

Eu listo isso como Java 7, porque pode gerar resultados diferentes para diferentes versões do Java.

Primeiras saídas (enviadas para stderr):

Error: Could not find or load main class Blank

Blank.java:1: error: class, interface, or enum expected
Error: Could not find or load main class Blank
^
Blank.java:1: error: reached end of file while parsing
Error: Could not find or load main class Blank
                                              ^
2 errors

Blank.java:1: error: class, interface, or enum expected
Blank.java:1: error: class, interface, or enum expected
^
Blank.java:1: error:  expected
Blank.java:1: error: class, interface, or enum expected
                          ^
Blank.java:1: error:  expected
Blank.java:1: error: class, interface, or enum expected
                                     ^
Blank.java:1: error: as of release 5, 'enum' is a keyword, and may not be used as an identifier
Blank.java:1: error: class, interface, or enum expected
                                          ^
  (use -source 1.4 or lower to use 'enum' as an identifier)
Blank.java:1: error: = expected
Blank.java:1: error: class, interface, or enum expected
                                               ^
Blank.java:2: error:  expected
Error: Could not find or load main class Blank
     ^
Blank.java:2: error: ';' expected
Error: Could not find or load main class Blank
      ^
Blank.java:2: error: = expected
Error: Could not find or load main class Blank
                      ^
Blank.java:2: error: = expected
Error: Could not find or load main class Blank
                                   ^
Blank.java:2: error:  expected
Error: Could not find or load main class Blank
                                              ^
Blank.java:3: error: = expected
^
^
Blank.java:3: error: ';' expected
^
 ^
Blank.java:4: error: illegal start of type
Blank.java:1: error: reached end of file while parsing
     ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
          ^
Blank.java:4: error: illegal start of type
Blank.java:1: error: reached end of file while parsing
           ^
Blank.java:4: error:  expected
Blank.java:1: error: reached end of file while parsing
            ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
          ^
Blank.java:4: error: illegal start of type
Blank.java:1: error: reached end of file while parsing
           ^
Blank.java:4: error:  expected
Blank.java:1: error: reached end of file while parsing
            ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
              ^
Blank.java:4: error: ';' expected
Blank.java:1: error: reached end of file while parsing
                   ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
                                 ^
Blank.java:4: error:  expected
Blank.java:1: error: reached end of file while parsing
                                        ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
                                         ^
Blank.java:4: error: ';' expected
Blank.java:1: error: reached end of file while parsing
                                              ^
Blank.java:5: error:  expected
Error: Could not find or load main class Blank
     ^
Blank.java:5: error: ';' expected
Error: Could not find or load main class Blank
      ^
Blank.java:5: error: = expected
Error: Could not find or load main class Blank
                      ^
Blank.java:5: error: = expected
Error: Could not find or load main class Blank
                                   ^
Blank.java:5: error:  expected
Error: Could not find or load main class Blank
                                              ^
Blank.java:6: error: = expected
                                              ^
                                              ^
Blank.java:6: error: ';' expected
                                              ^
                                               ^
Blank.java:7: error: reached end of file while parsing
2 errors
        ^
30 errors

HQ9 +, HQ9 ++ e similares, 2 caracteres

QQ

Esta é a saída:

QQQQ

Ruby 27

Uma versão muito modificada disso ( via ):

puts <<3*3,3
puts <<3*3,3
3

O número de vezes que a putslinha é impressa aumenta exponencialmente.

$ ruby quine.rb | ruby | ruby
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
3

$ ruby quine.rb | ruby | ruby | ruby | ruby | ruby | ruby | ruby | wc -l
    3283

Cálculo Lambda - 29

Um termo lambda simples

(λu.(u u)(u u))(λu.(u u)(u u))

Reduzir esse termo em uma redução beta rende

((λu.(u u)(u u))(λu.(u u)(u u)))((λu.(u u)(u u))(λu.(u u)(u u)))

E assim por diante. É uma variante simples do clássico, (λu.u u)(λu.u u)que é uma solução no cálculo lambda. A aplicação dupla aqui significa que obtemos o dobro da produção.

Script SH, 9

cat $0 $0

Cresce a uma taxa exponencial.

Execute como sh whatever.shou defina-o como executável.

A versão do Windows está aqui .

dc 11

Bem simples:

6579792
dfP

A primeira linha é repetida uma vez a cada geração:

$ dc growing_quine.dc
6579792
6579792
dfP

$ dc growing_quine.dc | dc | dc 
6579792
6579792
6579792
6579792
dfP

A última linha consiste nas seguintes instruções: dduplica o último valor colocado na pilha (6579792) (para obter mais uma cópia cada vez que a rodamos), fimprime a pilha inteira (que é um monte do mesmo número) e Pimprime o número (6579792) como um fluxo de bytes, exibido como dfP.

redcode (solução recursiva)

Este é o código do guerreiro mais fácil de escrever no redcode , o famoso Imp:

MOV 0, 1

Quando executado, o código grava uma cópia de sua única instrução no próximo endereço na memória; depois executa, etc.

Python 3-55

print(open(__file__).read())
f=lambda:print('f()')
f()

Isso poderia ser mais curto, substituindo __ file__ por um único nome de arquivo e salvando o arquivo como tal, mas achei que essa resposta estava mais no espírito da pergunta. Após uma iteração, ele gera:

print(open(__file__).read())
f=lambda:print('f()')
f()
f()

Conversa pequena, 125 61 57

A versão do golf parece quase ilegível, então vou explicar primeiro (e usar identificadores reais).

Essa é uma variante do método de modificação automática "maneira mais estranha de produzir um estouro de pilha".

O método imprime uma mensagem de saudação e sua fonte atual (apenas para demonstração). Em seguida, o código é modificado para gerar uma string mais longa e instalado. Finalmente, o novo código é chamado recursivamente.

Para me proteger de um fugitivo imediato, ele permite que o usuário confirme em cada ciclo.

compilar em Object:

eatMe_alice
   |msg mySource|

   mySource := thisContext method source.

   '**** Hello Alice' printCR.
   '  ---- my current code is:' printCR.
   mySource printCR.
   '  ---------------' printCR.

   (UserConfirmation confirm:'Again? ') ifTrue:[
       Object compile:
            (mySource
                copyReplaceString:'Hello ','Alice'
                withString:'Hello ','Alice !').
       self eatMe_alice
   ]

comece o show enviando "eatMe_alice" para qualquer objeto; nada fará:

nil eatMe_alice

Uma boa variante é não chamar o novo código recursivamente, mas iterativamente, desenrolando a pilha de chamadas e retornando ao novo método. Isso tem a vantagem de não levar a uma exceção de recursão. Para fazer isso, substitua a chamada recursiva ("self eatMe_alice") por:

thisContext resend

Golfe:

Obviamente, a impressão e a chamada automática não foram solicitadas; portanto, o mais curto (para golfe) é simplesmente anexar um comentário à minha própria fonte e devolvê-lo. Como efeito colateral, ele também é instalado para a próxima chamada ...

x|s|Object compile:(s:=thisContext method source,'""').^s

Script SH, 12 8 7

Armazene um arquivo com

sed p *

em seu próprio diretório vazio e execute a partir desse diretório usando sh [file]ou definido executável.

Alternativa antiga com 8 caracteres , mas não precisa de diretório próprio. Armazene um arquivo com

sed p $0

e execute usando sh [file]ou defina executável.

Alternativa antiga com 12 caracteres :

sed -i- p $0

Na verdade, isso resultará no próprio arquivo de programa, mas o local onde a saída não foi especificada. Se replica a uma taxa exponencial.

JavaScript, 41 , 40 caracteres

function f(){console.log(f+"f(f())")}f()

A primeira vez que você o executa, ele se apresenta com outro ;f()no final. Execuções subsequentes da saída resultam em cada fonte de "entrada" impressa duas vezes.

alertseria mais curto do que, console.logmas não considero várias caixas de diálogo de alerta como "a" saída, embora pareça razoável chamar várias linhas no console como saída.

J , 1 byte

'

Experimente online!

A citação aberta fornece, obviamente, o erro de citação aberta:

|open quote
|   '
|   ^
|[-1] /home/runner/.code.tio

Observe que, pela natureza do interpretador J, os erros são impressos em STDOUT , não em STDERR.

Quando o acima é executado como código, ele imprime:

|open quote
|   |   '
|       ^
|[-2] /home/runner/.code.tio

Então

|open quote
|   |   |   '
|           ^
|[-2] /home/runner/.code.tio

e assim por diante. Cada vez que o código é executado, a segunda linha é preenchida à esquerda com quatro bytes |   , cumprindo os requisitos deste desafio.

J , variante quine adequada, 25 bytes

echo,~'echo,:~(,quote)'''

Experimente online!

Saídas

echo,:~(,quote)'echo,:~(,quote)'

E então ele se produz duas vezes, em linhas separadas:

echo,:~(,quote)'echo,:~(,quote)'
echo,:~(,quote)'echo,:~(,quote)'

então

echo,:~(,quote)'echo,:~(,quote)'
echo,:~(,quote)'echo,:~(,quote)'
echo,:~(,quote)'echo,:~(,quote)'
echo,:~(,quote)'echo,:~(,quote)'

e assim por diante.

A primeira saída é uma variante simples do J Quine padrão . A adição ,:~concatena-se verticalmente, onde a matriz 2D resultante é impressa como duas linhas da mesma string.

Windows .BAT, 25

@COPY %~nx0+%~nx0 CON>NUL

Cresce a uma taxa exponencial.

Versão SH equivalente aqui .

reticular, 11 bytes, não-competitivo

"'34'coo1o;

Essa é a estrutura padrão do quine, exceto que um extra 1é impresso após cada iteração. Experimente online!

Primeiras saídas:

"'34'coo1o;
"'34'coo1o;1
"'34'coo1o;11
"'34'coo1o;111

Microscript II, 6 bytes

Não-competitivo, o idioma adia o desafio.

"qp"qp

A primeira iteração adiciona um extra qpao final, e cada iteração sucessiva adiciona uma cópia extra desse programa original ao início.

Encantos Rúnicos , 6 bytes

"'<S@>

Experimente online!

Este foi estranho. Tudo o que eu tinha que fazer era remover um ~dos resultados encontrados por Jo King .

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

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

Todos os quais não fazem nada.

EcmaScript 6 (51 bytes):

(_=x=>'(_='+_+Array(x++).join(','+_)+')('+x+')')(2)

Ele produz uma versão mais longa de si mesmo, que pode produzir uma versão mais longa de si mesmo, que pode produzir uma versão mais longa de si mesmo, etc.

PHP, 38

<?echo fgets(fopen(__FILE__,'r')).';';

Ele adicionará um ponto-e-vírgula a cada execução.

ECMAScript 6 (38 caracteres)

(f=_=>'(f='+f+')();(f='+f+')();')();

Quais saídas:

(f=_=>'(f='+f+')();(f='+f+')();')();(f=_=>'(f='+f+')();(f='+f+')();')();

Editar

Você poderia fazer (28 caracteres):

(f=_=>'(f='+f+')();'+f())();

No entanto, ele será repetido infinitamente e nunca retornará nada ... mas isso pode ser resolvido fazendo algo assim (42 caracteres):

(f=_=>_?'(f='+f+')('+_+');'+f(_-1):'')(3);

Qual saída:

(f=_=>_?'(f='+f+')('+_+');'+f(_-1):'')(3);(f=_=>_?'(f='+f+')('+_+');'+f(_-1):'')(2);(f=_=>_?'(f='+f+')('+_+');'+f(_-1):'')(1);

Lisp comum, 16 caracteres

(print `(or ,-))

Concedido, é apenas interativo, mas poder fazer referência ao formulário atual de nível superior é provavelmente a melhor maneira de minimizar um programa não trivial que atenda às especificações.

O que seria realmente interessante é o que explode mais rápido. Talvez algo como

(print `(progn ,@(loop repeat (length -) collect -)))

Julia, 66 caracteres

x="print(\"x=\$(repr(x))\\n\$x;\"^2)";print("x=$(repr(x))\n$x;"^2)

Saída (134 caracteres):

x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);

Resultado da execução do resultado (268 caracteres):

x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);

próximo resultado (536 caracteres):

x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);

Próximo resultado (1072 caracteres):

x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);

Espero que isso esteja de acordo com as regras.

Produz uma saída maior e a saída em si é um código-fonte válido que produz uma saída maior novamente.

05AB1E, 15 bytes, não competidor

0"DÐ34çý"DÐ34çý

Experimente online!

Impressões 0"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý,
que imprime 0"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý,
etc.

Evoloop, retângulo 9 × 9 (81 células)

O autômato celular Evoloop incluído no Golly suporta padrões que se reproduzem de maneira "semelhante a um quine". Especificamente, esses padrões contêm um "programa"; um padrão se reproduz executando primeiro o programa (que cria o "corpo" da filha) e, em seguida, copiando o programa para a filha.

O exposto acima se aplica aos mais famosos autômatos celulares "Langton's Loops", bem como ao Evoloop, mas o Evoloop tem uma diferença interessante: é fácil criar um padrão que cresce a cada geração sucessiva.

(Muito mais interessante, na minha opinião, é o fato de o Evoloop ser um autômato celular simples que contém padrões que se reproduzem e evoluem de uma maneira muito semelhante à vida! Acho que os únicos autômatos celulares conhecidos que fazem isso são o Evoloop e seus descendentes Uma falha do Evoloop, no entanto, é que existe um genoma "melhor" em particular; a evolução sempre acaba convergindo para esse genoma.)

Agora, existem duas deficiências nessa submissão. Uma é que não está claro qual é a "saída" de um autômato celular. Mas acho que um autômato auto-reprodutivo é "suficientemente próximo" para ser um quine; certamente não é menos interessante! A outra falha é que esses padrões não criam apenas uma única cópia de si mesmos; cada cópia do padrão original tenta criar infinitas cópias de si mesma, e essas cópias acabam interagindo umas com as outras de maneira destrutiva. Então, acho que cumpri os requisitos desse desafio em espírito, mas não em letra.

Sem mais delongas, o padrão é:

022222220
270170172
212222202
202000212
272000272
212000202
202222212
271041032
022222250

Aqui está o padrão novamente, em um formato que pode ser copiado e colado no Golly:

x = 9, y = 9, rule = Evoloop
.7B$BG.AG.AGB$BA5B.B$B.B3.BAB$BGB3.BGB$BAB3.B.B$B.5BAB$BGA.DA.CB$.6BE
!

Ok, mas como é? Se parece com isso:

Na animação acima, você pode ver o padrão inicial criar uma filha maior, que cria uma neta maior, depois uma bisneta maior e, finalmente, uma bisneta ainda maior, que começa a construir uma terceira bisneta ainda maior. neta. Se você seguisse esse padrão por um longo tempo, ele continuaria assim para sempre (ou talvez eles acabassem sendo ultrapassados ​​pelos organismos desenvolvidos, que são capazes de se reproduzir muito mais rápido; não tenho certeza).

LOTE, 26

Coloque esse código em qualquer arquivo .bat e ele continuará sendo executado (em um loop infinito) e o arquivo também aumentará.

echo echo %0 ^>^> %0 >> %0

PYG (6)

P(Q,Q)

Imprime seu próprio código-fonte, separado por novas linhas. A segunda geração seria

P(Q,Q)
P(Q,Q)

e assim por diante.

ÓLEO , 83 bytes

0
0
1
1
1
4
1
11
4
1
11
1
2
2
1
12
18
10
18
1
32
22
1
18
26
4
26
8
18
11
6
17
4
26

Primeiro imprime duas linhas com zero nelas e, em seguida, compara cada linha com a linha 1, se elas são iguais (como é o caso quando o arquivo está esgotado), imprimimos o que está na célula 26. A saída resultante será semelhante à mesmo, exceto com uma adição 33, que não faz nada. Da próxima vez, outra linha será adicionada e assim por diante.

Ajuda, WarDoq! , 1 byte.

H

Imprime Hello, World!.

Outros caracteres além de H são códigos fonte válidos (e seguros) (que imprimem outras variantes do Hello World).