Su objetivo es crear un programa que se imprima indefinidamente, con una nueva línea después de cada uno. Por lo tanto, si su programa es de una sola línea, se repetirá en cada línea de la salida.

Ejemplo

Programa:

A

Salida:

A
A
A
...

Reglas

• Debe ser un programa completo, no un fragmento o función.
• El programa debería repetirse para siempre sin desbordamiento de pila o errores de límite de recursión.
• La salida es stdout o la alternativa más cercana.
• No se acepta entrada de programa.
• Las lagunas estándar no están permitidas, como abrir el archivo del programa o acceder a un recurso externo. Los programas vacíos no están permitidos como un vacío legal estándar.
• Si el código de su programa termina con una nueva línea final, esto no cuenta como la nueva línea necesaria entre las líneas, y debe imprimir otra.
• codegolf - ¡El código más corto gana!

Fisión, 7 bytes

'!+!NR"

Una modificación bastante simple de la quine de fisión más corta que he encontrado hasta ahora : simplemente estoy usando la no destructiva en !lugar de Oy agregué una Npara nueva línea.

En resumen, así es como funciona: el flujo de control comienza en el Rcon un átomo a la derecha. "alterna el modo de cadena, lo que significa todo hasta que "se imprima el siguiente : en este caso '!+!NR. Eso deja la "y la nueva línea para imprimir. '!establece la masa del átomo en 33, la +incrementa a 34 (el código de caracteres de ") e !imprime la cita. Nimprime una nueva línea y Rahora no funciona en este caso, por lo que el ciclo comienza de nuevo.

La siguiente solución de 7 bytes también funciona:

"NR'!+!

> <> , 16 bytes

'ard3*o50l2)?.~~

La tradicional> <> quine usa demasiados os, así que usamos un bucle para imprimir. Antes de cada salto, presionamos 5 y 0 (las coordenadas de hacia dónde saltar), después de lo cual saltamos .si todavía hay algo para imprimir o aparecen los dos valores superiores ~~.

(Volví a la versión 16 ya que olvidé la regla de desbordamiento de pila).

CJam, 13 bytes

{_o"_g
"o1}_g

El intérprete en línea no imprime nada antes de que finalice el programa, por lo que tendrá que probar esto en el intérprete de Java.

Explicación

Finalmente, una quine CJam generalizada que no termina en _~.

{_o"_g
"o1}

Esto simplemente empuja un bloque. _gduplica el bloque y lo ejecuta repetidamente mientras la parte superior de la pila es verdadera (descartando la condición).

Ahora dentro del bloque, la otra copia del bloque todavía está en la pila. Lo duplicamos e imprimimos con _oy luego imprimimos _gseguido de una nueva línea (la nueva línea adicional requerida entre las líneas) con "_g\n"o. Finalmente, empujamos a 1a la pila para que se repita el ciclo, porque desafortunadamente, los bloques no son verdaderos (o falsos) en CJam.

Pitón 2, 39

No es una tarea muy interesante en Python, ya que es trivial agregar el ciclo while a una 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

o (también 37 bytes)

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

Invocar con el indicador de línea de comando -M5.010o -E, por ejemplo

$ 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
...

Gracias a Ilmari Karonen por eliminar 3 bytes de mi solución original, que fue:

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

Esto, así como las soluciones más cortas de 37 bytes anteriores, son variaciones simples de la siguiente frase, que vi por primera vez en una de las otras publicaciones de Ilmari :

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

Como todo lo que agregué en mi solución original fue un whilebucle, realmente merece la mayor parte del crédito. :-)

Brainf *** auto modificable (SMBF) , 14 bytes

La nueva línea final \ndebe ser una nueva línea literal, Unix, (código ASCII 10).

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

Explicación:

El código mueve el puntero al extremo izquierdo de su código fuente, luego lo imprime todo, incluida la nueva línea (dos veces b / c de la regla). El ciclo continúa.

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

Basado del Código Rosetta PowerShell Quine , estoy bastante seguro de que este no es el más corto posible. El formato de reemplazo de cadenas en PowerShell es difícil para esto, porque los mismos delimitadores para dónde colocar los reemplazos {}también delimitan los bloques de código while{}, por lo que tenemos que usar la [char]conversión, que hincha el código un montón.

Baja carga, 25 bytes

La primera vez que probé algo como esto y no estoy seguro si sigue todas las reglas, ya que se trata de un par de líneas. La nueva línea fue un poco dolorosa.

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

Befunge , 30 20 bytes

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

Una variación de una popular quine befunge que imprime una nueva línea y aparece -1 en la pila si termina la línea.
Desafortunadamente, Befunge se vuelve detallado cuando hace cosas en una línea. Traté de eliminar todos los launchpads ( #) que pude, pero tuve que dejar algunos para omitir ciertos comandos (como ,).

Cambios:

30-20 -> cambié la base quine a una personalizada que hice que usa la entrada de cadena. De esta manera, la ramificación es mucho más fácil.

Antiguo:

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

No creo que esto sea óptimo, pero es aceptable por ahora.

K, 30 bytes

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

R, 34 bytes

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

invocar desde la línea de comando de la siguiente manera:

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

> <>, 31 29 bytes

Una simple modificación de la tradicional > <> quine .

"ar00gc0.0+efooooooooooooooo|

Para ejecutarlo, péguelo aquí , haga clic en 'Enviar', luego 'Iniciar' (ejecutar sin animación no funciona). Siéntase libre de aumentar la velocidad de ejecución.

Python 2, 48 bytes

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

GolfScript, 16 bytes

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

Esto terminó pareciéndose mucho a la entrada de Martin Büttner en CJam . Una característica interesante es que, como resulta, la forma más corta de agregar ".do"al bloque cuando se imprime es asignarlo al terminador de línea n. (Por supuesto, también debemos incluir una nueva línea real en la cadena, para reemplazar la que nnormalmente contiene). La misma cadena (siendo sincera en GolfScript) también se deja en la pila para que el dobucle salte, asegurando que el bucle corre por siempre.

BASH, 76 bytes

Simplemente no pude resistirme, especialmente con PowerShell aquí :)

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

El espacio en blanco es importante para una copia EXACTA.

Javascript (ES6), 64

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

Alternativamente (también 64)

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

Microscript , 22 bytes

"f1{CqxCanx"f1{CqxCanx

Sobre la base de la quine del artículo de Esolangs: "fCqxah"fCqxah. Explota el hecho de que el lenguaje aplica automáticamente llaves de cierre según sea necesario, sin lo cual esto sería dos bytes más largos.

Lote, 10 (+ 4 para la longitud del nombre del archivo)

No estoy seguro si esto califica por dos razones:

• Técnicamente, puede haber o no efectos secundarios textuales del shell de comandos de Windows, ya que eso depende de cómo esté configurado.
• Este programa se invoca por su nombre, y no estoy seguro de si eso está prohibido por las reglas (específicamente la regla de "no abrir el archivo de programa"). No se abre para leer e imprimir el texto; simplemente se está volviendo a ejecutar. Además, la estructura del sistema de archivos es una parte integral de las secuencias de comandos por lotes de la vieja escuela (a menudo incluso se usa para almacenar el estado del programa, etc.). Como tal, no estoy seguro de si esto viola la quinta regla o no.

El código (para un programa llamado q.bat):

echo on&&q

Ceilán , 210 208 bytes

Por supuesto, esto no ganará 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);}}

Modifiqué mi Quine de hace dos días agregando el while(true){...}bucle, por lo que vengo de los 185 bytes del Quine simple a 210 (ya no necesito el nuevo carácter de línea final). Pero luego descubrí que un while(1<2){...}bucle es incluso dos bytes más corto:

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

(Ceilán no tiene un for(;;)bucle como Java, y las llaves también son necesarias para este bucle).

PowerShell, 132107 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}

Basado en Rosetta Quine (igual que @AdmBorkBork) aunque no utiliza el formato para el reemplazo de la cadena ... ¿tal vez cambiar a un bucle for y usar el formato sería lo mejor?

Estoy seguro de que si AdmBorkBork regresara, lo superarían mucho: P

EDITAR Descubrí el bucle for y los reemplazos, todo gracias a mi predecesor :)

Viejo intento:

$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

Una modificación de una de las quines de Ruby encontradas aquí .

_="_=%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));}}

Explicación:

Pruébelo en línea (agota el tiempo de espera después de 60 segundos).

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 -parte:

• La cuerda s contiene el código fuente sin formato.
• %s se utiliza para ingresar esta cadena en sí misma con el s.format(...) .
• %c, %1$cy 34se usan para formatear las comillas dobles.
• s.format(s,34,s) lo pone todo junto

Parte del desafío:

• for(;;) se usa para recorrer indefinidamente.
• System.out.println(...) se utiliza para imprimir con una nueva línea al final

Funky , 29 bytes

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

Pruébalo en línea!

RProgN 2 , 7 bytes

«]³]]p:

Pruébalo en línea!

Jalea , 14 bytes

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

Pruébalo en línea!

Pyth, 11 bytes

#jN B"#jN B

Pruébalo aquí!

Brachylog , 16 bytes

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

No puedes probarlo en línea , pero he verificado que funciona en mi instalación.

Brachylog , 18 bytes

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

Pruébalo en línea!

Adaptado de la versión alternativa de este quine , con un truco de retroceso que había ideado inicialmente para bogosort de todas las cosas. Gasta dos bytes ~nporque ẉ(el medio habitual para imprimir con una nueva línea final) tiene algunos problemas extraños con la codificación de caracteres en TIO, y una nueva línea real insertada en el literal de cadena se imprime ~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.

Dado que w₁toma la entrada como una lista [string to be formatted, formatting arguments], envolver una cadena en una lista y gluego concatenarla con ella misma jpermite formatearla consigo misma. Y dado que no se proporciona ninguna entrada al programa, la variable de entrada que está implícitamente presente al comienzo del programa puede tomar cualquier valor, por lo que puede restringirse a una de las infinitas listas que contienen "∋~kgjw₁⊥~n"como elemento, creando un solo punto de elección al que se debe realizar un seguimiento cuando, después de imprimir su origen, el programa llega ⊥.

Python 3.6, 48 43 bytes.

-5 bytes gracias a @Jo King

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

Gol> <> , 10 bytes

"r2sslRoao

Pruébalo en línea!

Esto probablemente se puede jugar más golf