Seu objetivo é criar um programa que se imprima indefinidamente, com uma nova linha após cada um. Portanto, se o seu programa for de uma linha, ele será repetido em todas as linhas da saída.

Exemplo

Programa:

A

Saída:

A
A
A
...

Regras

• Ele deve ser um programa completo, não um trecho ou função.
• O programa deve executar um loop para sempre, sem erros de limite de recursão ou excesso de pilha.
• A saída é stdout ou a alternativa mais próxima.
• Nenhuma entrada de programa é aceita.
• As brechas padrão não são permitidas, como abrir o arquivo do programa ou acessar um recurso externo. Programas vazios não são permitidos como brechas padrão.
• Se o código do seu programa terminar com uma nova linha à direita, isso não conta como a nova linha necessária entre as linhas e você deve imprimir outra.
• codegolf - O código mais curto vence!

Fissão, 7 bytes

'!+!NR"

Uma modificação bastante simples do quine de Fissão mais curto que encontrei até agora : estou simplesmente usando o não destrutivo em !vez de Oe adicionei um Npara nova linha.

Então, em suma, eis como funciona: o fluxo de controle começa no Rátomo certo. "alterna o modo de sequência, o que significa tudo até a próxima "impressão: neste caso '!+!NR. Isso deixa a "nova linha a ser impressa. '!define a massa do átomo em 33, a +incrementa em 34 (o código de caractere de ") e !imprime a citação. Nimprime uma nova linha e Ragora não funciona nesse caso, para que o loop recomeça.

A seguinte solução de 7 bytes também funciona:

"NR'!+!

> <> , 16 bytes

'ard3*o50l2)?.~~

A quina tradicional> <> usa muitos o s, então usamos um loop para impressão. Antes de cada salto, pressionamos 5 e 0 (as coordenadas de onde pular), após o qual pulamos .se ainda houver algo para imprimir ou exibimos os dois principais valores ~~.

(Revertida para a versão 16 desde que me esqueci da regra de estouro de pilha.)

CJam, 13 bytes

{_o"_g
"o1}_g

O intérprete online não imprime nada antes que o programa termine, portanto, você precisará testá-lo no interpretador Java.

Explicação

Finalmente, uma solução CJam generalizada que não termina em _~.

{_o"_g
"o1}

Isso simplesmente empurra um bloco. _gduplica o bloco e o executa repetidamente enquanto a parte superior da pilha é verdadeira (descartando a condição).

Agora dentro do bloco, a outra cópia do bloco ainda está na pilha. Nós o duplicamos e imprimimos com _oe, em seguida, imprimimos _gseguidos por uma nova linha (a nova linha extra necessária entre linhas) com "_g\n"o. Finalmente, pressionamos um 1na pilha para que o loop se repita, porque, infelizmente, os blocos não são verdadeiros (ou falsos) no CJam.

Python 2, 39

Não é uma tarefa muito interessante em Python, pois é trivial adicionar o loop while a um quine normal.

c='while 2:print"c=%r;exec c"%c';exec c

Perl 5.10+, 40 37 bytes

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

ou (também 37 bytes)

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

Chame com o sinalizador de linha de comando -M5.010ou -E, por exemplo

$ perl -E '$_=q{say"\$_=q{$_};eval"while 1};eval'
$_=q{say"\$_=q{$_};eval"while 1};eval
$_=q{say"\$_=q{$_};eval"while 1};eval
$_=q{say"\$_=q{$_};eval"while 1};eval
...

Agradeço a Ilmari Karonen por remover 3 bytes da minha solução original, que foi:

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

Isso, bem como as soluções mais curtas de 37 bytes acima, são todas variações simples do seguinte quine, que eu vi pela primeira vez em uma das outras postagens de Ilmari :

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

Como tudo o que adicionei na minha solução original foi um whileloop, ele realmente merece a maior parte do crédito. :-)

Brainf com modificação automática *** (SMBF) , 14 bytes

A nova linha \nà direita precisa ser uma linha literal, Unix, (código ASCII 10).

[<[<]>[.>]<.]\n

Explicação:

O código move o ponteiro para a extrema esquerda do seu código-fonte e depois imprime tudo, incluindo a nova linha (duas vezes b / c da regra). O loop continua.

PowerShell, 143 bytes

$d='$d={0}{1}{0}{2}while(1){3}Write($d -f [char]39,$d,"`n",[char]123,[char]125){4}'
while(1){Write($d -f [char]39,$d,"`n",[char]123,[char]125)}

Baseado no quine do Rosetta Code PowerShell , estou bastante confiante de que esse não é o mais curto possível. A formatação de substituição de cadeia de caracteres no PowerShell é difícil para isso, porque os mesmos delimitadores para onde colocar as substituições {}também delimitam blocos de código while{}, por isso temos que usar a [char]conversão, que incha o código bastante.

Carga insuficiente, 25 bytes

Primeira vez que tentei algo assim e não tenho certeza se segue todas as regras, pois são algumas linhas. A nova linha foi um pouco dolorosa.

(::a~*S:a~*^
)::a~*S:a~*^

Befunge , 30 20 bytes

<,+55,*2+98_ #!,#:<"

Uma variação de um quine befunge popular que imprime uma nova linha e aparece -1 na pilha se terminar a linha.
Infelizmente, o Befunge fica detalhado ao fazer as coisas em uma linha. Tentei remover todas as barras de ativação ( #) que pude, mas algumas tiveram que ser deixadas para pular determinados comandos (como ,).

Alterar:

30-20 -> alterou o quine base para um personalizado que fiz que usa entrada de string. Dessa forma, a ramificação é muito mais fácil.

Velho:

:0g,:93*`>0-10 #,+$#: #5 _1+>

Não acho que isso seja ideal, mas é aceitável por enquanto.

K, 30 bytes

{f:$_f;{x}{`0:f,"[]\n";1}/1}[]

R, 34 bytes

repeat{write(commandArgs()[5],'')}

para chamar a partir da linha de comando da seguinte maneira:

Rscript -e "repeat{write(commandArgs()[5],'')}"

> <>, 31 29 bytes

Uma simples modificação da tradicional > <> quine .

"ar00gc0.0+efooooooooooooooo|

Para executar, cole-o aqui , clique em 'Enviar' e depois em 'Iniciar' (a execução sem animação não funciona). Sinta-se livre para aumentar a velocidade de execução.

Python 2, 48 bytes

c='c=\'%s\';while 1:print c%c';while 1:print c%c

GolfScript, 16 bytes

{.".do
":n\p}.do

Isso acabou parecendo muito com a entrada de Martin Büttner no CJam . Uma característica interessante é que, como se vê, a maneira mais curta de anexar ".do"ao bloco quando impresso é atribuí-lo ao terminador de linha n. (Obviamente, também precisamos incluir uma nova linha real na string, para substituir a que nnormalmente contém.) A mesma string (sendo verdadeira no GolfScript) também é deixada na pilha para que o doloop saia, garantindo que o loop corre para sempre.

BASH, 76 bytes

Não pude resistir, especialmente com o PowerShell aqui :)

while true;do
a ()
{
    echo while true\;do
    declare -f a
    echo a\;done
}
a;done

O espaço em branco é importante para uma cópia EXATA.

Javascript (ES6), 64

for(;;(_=>console.log(`for(;;(_=>${arguments.callee})());`))());

Alternativamente (também 64)

a="for(;;)console.log(`a=${JSON.stringify(a)};eval(a)`)";eval(a)

Microscript , 22 bytes

"f1{CqxCanx"f1{CqxCanx

Com base na Quine do artigo Esolangs: "fCqxah"fCqxah. Explora o fato de que o idioma anexa automaticamente chaves de fechamento conforme necessário, sem o qual seriam dois bytes mais longos.

Lote, 10 (+ 4 para o tamanho do nome do arquivo)

Não tenho certeza se isso está qualificado por dois motivos:

• Tecnicamente, pode haver ou não efeitos colaterais de texto no shell de comando do Windows, pois isso depende de como está configurado.
• Este programa se chama pelo nome e não tenho certeza se isso é proibido pelas regras (especificamente a regra "sem abertura do arquivo de programa"). Não está se abrindo para fins de leitura e impressão do texto; está simplesmente se re-executando. Além disso, a estrutura do sistema de arquivos é parte integrante dos scripts em lote da velha escola (muitas vezes sendo usados ​​para armazenar o estado do programa etc.). Como tal, não tenho certeza se isso viola a 5ª regra ou não.

O código (para um programa chamado q.bat):

echo on&&q

Ceilão , 210 208 bytes

Claro que isso não vai ganhar nada ...

shared void u(){value q="\"\"\"";value t="""shared void u(){value q="\"\"\"";value t=""";value b="""while(1<2){print(t+q+t+q+";value b="+q+b+q+";"+b);}}""";while(1<2){print(t+q+t+q+";value b="+q+b+q+";"+b);}}

Original:

shared void u(){value q="\"\"\"";value t="""shared void u(){value q="\"\"\"";value t=""";value b="""while(true){print(t+q+t+q+";value b="+q+b+q+";"+b);}}""";while(true){print(t+q+t+q+";value b="+q+b+q+";"+b);}}

Eu modifiquei meu Quine de dois dias atrás , adicionando o while(true){...}loop, então venho dos 185 bytes do Quine simples para 210 (não preciso mais do caractere de nova linha à direita). Mas então eu descobri que umwhile(1<2){...} loop é até dois bytes mais curto:

shared void u(){value q="\"\"\"";value t="""shared void u(){value q="\"\"\"";value t=""";value b="""while(1<2){print(t+q+t+q+";value b="+q+b+q+";"+b);}}""";while(1<2){print(t+q+t+q+";value b="+q+b+q+";"+b);}}

(O Ceilão não possui for(;;)loop como Java, e as chaves também são necessárias para esse loop.)

PowerShell, 132 107 bytes

$a='$a={0}{1}{0};for(){2}$a-f[char]39,$a,[char]123,[char]125{3}';for(){$a-f[char]39,$a,[char]123,[char]125}

Baseado no Rosetta Quine (o mesmo que @AdmBorkBork), embora não use a formatação para substituir a string ... talvez seja melhor alternar para um loop for e usar a formatação?

Tenho certeza que se o AdmBorkBork voltar, eles vencerão muito: P

EDITAR Descobri o loop for e substituições, tudo graças ao meu antecessor :)

Antiga tentativa:

$a='$a=;for(){$a.substring(0,3)+[char]39+$a+[char]39+$a.substring(3)}';for(){$a.substring(0,3)+[char]39+$a+[char]39+$a.substring(3)}

Ruby, 41 39 bytes

Uma modificação de um dos códigos de Ruby encontrados aqui .

_="_=%p;loop{puts _%%_}";loop{puts _%_}

Java 10, 194 bytes

interface M{static void main(String[]a){for(var s="interface M{static void main(String[]a){for(var s=%c%s%1$c;;)System.out.println(s.format(s,34,s));}}";;)System.out.println(s.format(s,34,s));}}

Explicação:

Experimente online (o tempo limite termina após 60 s).

interface M{                    // Class
  static void main(String[]a){  //  Mandatory main-method
    for(var s="interface M{static void main(String[]a){for(var s=%c%s%1$c;;)System.out.println(s.format(s,34,s));}}";
                                //   Unformatted source code
        ;)                      //   Loop indefinitely
       System.out.println(      //    Print with trailing new-line:
         s.format(s,34,s));}}   //     The formatted source code

quine -part:

• A 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 o34 são usados para formatar as aspas.
• s.format(s,34,s) coloca tudo junto

Parte do desafio:

• for(;;) é usado para fazer um loop indefinidamente.
• System.out.println(...) é usado para imprimir com nova linha à direita

Funky , 29 bytes

f=@print`f=[f]for)f()`for)f()

Experimente online!

RProgN 2 , 7 bytes

«]³]]p:

Experimente online!

Gelatina , 14 bytes

“;@ṾṄṛ¢”;@ṾṄṛ¢

Experimente online!

Pitão, 11 bytes

#jN B"#jN B

Experimente aqui!

Braquilog , 16 bytes

∋"∋~kgjẉ₁⊥"gjẉ₁⊥

Você não pode experimentá-lo online , mas verifiquei que ele funciona na minha instalação.

Braquilog , 18 bytes

∋"∋~kgjw₁⊥~n"gjw₁⊥

Experimente online!

Adaptado da versão alternativa deste quine , com um hack de backtracking que eu havia inventado inicialmente para um bogoort de todas as coisas. Gasta dois bytes ~nporque ẉ(o meio usual de impressão com uma nova linha à direita) atinge alguns problemas estranhos com a codificação de caracteres no TIO, e uma nova linha real inserida na string literal é impressa ~kcomo \n.

               w      Print
 "∋~kgjw₁⊥~n"         "∋~kgjw₁⊥~n"
∋                     which is an element of
                      the (unused and unconstrained) input
                ₁     formatted
          ~n          (so that the ~n is replaced with a newline)
             gj       with itself
   ~k                 (so that the ~k is replaced with the string in quotes),
                 ⊥    then try again.

Como w₁recebe a entrada como uma lista [string to be formatted, formatting arguments], agrupar uma sequência em uma lista ge concatená-la consigo mesma jpermite que ela seja formatada consigo mesma. E como nenhuma entrada é fornecida ao programa, a variável de entrada que está implicitamente presente no início do programa pode assumir qualquer valor, portanto, pode ser restringida a uma das infinitas listas que contêm "∋~kgjw₁⊥~n"como elemento, criando uma única ponto de escolha a ser retornado para quando, após imprimir sua fonte, o programa for acessado ⊥.

Python 3.6, 48 43 bytes.

-5 bytes graças a @Jo King

x='while 1:print("x=%r;exec(x)"%x)';exec(x)

Gol> <> , 10 bytes

"r2sslRoao

Experimente online!

Provavelmente isso pode ser jogado mais