Il tuo obiettivo è quello di creare un programma che si stampi indefinitamente, con una nuova riga dopo ognuno. Pertanto, se il tuo programma è a linea singola, verrebbe ripetuto su ogni riga dell'output.

Esempio

Programma:

A

Produzione:

A
A
A
...

Regole

• Deve essere un programma completo, non uno snippet o una funzione.
• Il programma dovrebbe essere ripetuto per sempre senza errori di overflow dello stack o di limite di ricorsione.
• L'output è stdout o l'alternativa più vicina.
• Nessun input di programma accettato.
• Non sono consentite scappatoie standard, come l'apertura del file del programma o l'accesso a una risorsa esterna. I programmi vuoti non sono ammessi come scappatoia standard.
• Se il codice del programma termina con una nuova riga finale, questa non conta come la nuova riga necessaria tra le righe e devi stamparne un'altra.
• codegolf - Vince il codice più corto !

Fissione, 7 byte

'!+!NR"

Una modifica piuttosto semplice della quinta Fission più corta che ho trovato finora : sto semplicemente usando il non distruttivo !invece di Oe ho aggiunto un Nper newline.

Quindi, tutto sommato, ecco come funziona: il flusso di controllo inizia Rcon un atomo in corso. "attiva / disattiva la modalità stringa, il che significa tutto fino alla successiva "stampa: in questo caso '!+!NR. Ciò lascia la "e la nuova riga da stampare. '!imposta la massa dell'atomo su 33, la +incrementa su 34 (il codice carattere di ") e !stampa la citazione. Nstampa una nuova riga e Rin questo caso ora non è operativo, quindi il ciclo ricomincia.

La seguente soluzione a 7 byte funziona anche:

"NR'!+!

> <> , 16 byte

'ard3*o50l2)?.~~

Il tradizionale> <> quine usa troppi os, quindi usiamo un loop per la stampa. Prima di ogni salto spingiamo 5 e 0 (le coordinate di dove saltare), dopodiché saltiamo con .se c'è ancora qualcosa da stampare, o pop con i primi due valori ~~.

(Ripristinato alla versione 16 da quando ho dimenticato la regola di overflow dello stack.)

CJam, 13 byte

{_o"_g
"o1}_g

L'interprete online non stampa nulla prima che il programma sia terminato, quindi dovrai provarlo nell'interprete Java.

Spiegazione

Finalmente un quine CJam generalizzato che non finisce in _~.

{_o"_g
"o1}

Questo semplicemente spinge un blocco. _gduplica il blocco e lo esegue ripetutamente mentre la parte superiore della pila è vera (scartando la condizione).

Ora all'interno del blocco, l'altra copia del blocco è ancora in pila. Lo dupliciamo e lo stampiamo con _oe poi stampiamo _gseguito da una nuova riga (la nuova riga aggiuntiva necessaria tra le righe) con "_g\n"o. Alla fine, inseriamo una 1pila nello stack per ripetere il loop, perché purtroppo i blocchi non sono veritieri (o falsi) in CJam.

Python 2, 39

Non è un compito molto interessante in Python in quanto è banale aggiungere il ciclo while a un normale quine.

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

Perl 5.10+, 40 37 byte

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

o (anche 37 byte)

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

Richiamare con il flag della riga di comando -M5.010o -E, ad es

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

Grazie a Ilmari Karonen per aver rasato 3 byte dalla mia soluzione originale, che era:

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

Questa, così come le soluzioni a 37 byte più brevi sopra, sono tutte semplici varianti del seguente quine, che ho visto per la prima volta in uno degli altri post di Ilmari :

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

Dal momento che tutto ciò che ho aggiunto nella mia soluzione originale era un whileciclo, merita davvero la maggior parte del merito. :-)

Brainf *** (SMBF) automodificante , 14 byte

La newline finale \ndeve essere letterale, Unix, newline (codice ASCII 10).

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

Spiegazione:

Il codice sposta il puntatore all'estrema sinistra del suo codice sorgente, quindi stampa tutto, inclusa la nuova riga (due volte in b / c della regola). Il ciclo continua.

PowerShell, 143 byte

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

Basato sul quine di Rosetta Code PowerShell , sono abbastanza sicuro che questo non sia il più breve possibile. La formattazione di sostituzione delle stringhe in PowerShell è dannosa per questo, perché gli stessi delimitatori per dove inserire i rimpiazzi {}delimitano anche i blocchi di codice while{}, quindi dobbiamo usare il [char]cast, che gonfia il codice un mucchio.

Sottocarico, 25 byte

La prima volta che ho provato qualcosa del genere e non sono sicuro che segua tutte le regole in quanto è un paio di righe. La newline è stata un po 'dolorosa.

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

Befunge , 30 20 byte

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

Una variante di un popolare befunge quine che stampa una nuova riga e fa apparire -1 in pila se termina la linea.
Sfortunatamente, Befunge diventa prolisso quando fa le cose in una riga. Ho provato a rimuovere tutti i launchpad ( #) che potevo, ma alcuni dovevano essere lasciati dentro per saltare alcuni comandi (come ,).

I cambiamenti:

30-20 -> ha cambiato il quine di base con uno personalizzato che ho creato usando l'input di stringhe. In questo modo, la ramificazione è molto più semplice.

Vecchio:

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

Non penso che sia ottimale, ma per ora è accettabile.

K, 30 byte

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

R, 34 byte

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

per richiamare dalla riga di comando come segue:

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

> <>, 31 29 byte

Una semplice modifica del tradizionale > <> quine .

"ar00gc0.0+efooooooooooooooo|

Per eseguirlo, incollalo qui , fai clic su "Invia", quindi su "Avvia" (l'esecuzione senza animazione non funziona). Sentiti libero di aumentare la velocità di esecuzione.

Python 2, 48 byte

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

GolfScript, 16 byte

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

Questo finì per assomigliare molto alla voce CJam di Martin Büttner . Una caratteristica interessante è che, a quanto pare, il modo più breve per aggiungere ".do"al blocco quando è stampato è assegnarlo al terminatore di linea n. (Ovviamente, dobbiamo anche includere una nuova riga effettiva nella stringa, per sostituire quella nnormalmente contenuta.) La stessa stringa (essendo sincera in GolfScript) viene lasciata nello stack per dofar scattare il loop, assicurando che il loop corre per sempre.

BASH, 76 byte

Non ho potuto resistere, specialmente con PowerShell qui :)

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

Lo spazio bianco è importante per una copia ESATTA.

Javascript (ES6), 64

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

In alternativa (anche 64)

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

Microscript , 22 byte

"f1{CqxCanx"f1{CqxCanx

Sulla base della Quine dall'articolo Esolangs: "fCqxah"fCqxah. Sfrutta il fatto che la lingua aggiunge automaticamente le parentesi graffe di chiusura in base alle esigenze, senza le quali questo sarebbe più lungo di due byte.

Lotto, 10 (+ 4 per la lunghezza del nome file)

Non sono sicuro se questo si qualifica per due motivi:

• Tecnicamente, potrebbero esserci o meno effetti collaterali testuali dalla shell dei comandi di Windows, poiché ciò dipende da come è configurato.
• Questo programma si richiama per nome e non sono sicuro che sia proibito dalle regole (in particolare la regola "nessuna apertura del file di programma"). Non si sta aprendo allo scopo di leggere e stampare il testo; si sta semplicemente eseguendo nuovamente. Inoltre, la struttura del file system è parte integrante degli script batch della vecchia scuola (spesso utilizzati anche per memorizzare lo stato del programma, ecc.). Pertanto, non sono sicuro che ciò violi o meno la 5a regola.

Il codice (per un programma chiamato q.bat):

echo on&&q

Ceylon , 210 208 byte

Naturalmente questo non vincerà nulla ...

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

Originale:

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

Ho modificato il mio Quine da due giorni fa aggiungendo il while(true){...}loop, quindi vengo dai 185 byte del semplice Quine a 210 (non ho più bisogno del carattere di nuova riga finale). Ma poi ho scoperto che un while(1<2){...}ciclo è anche più breve di due byte:

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

(Ceylon non ha un for(;;)loop come Java, e anche le parentesi graffe sono necessarie per questo loop.)

PowerShell, 132 107 byte

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

Basato su Rosetta Quine (come su @AdmBorkBork) anche se non usa la formattazione per la sostituzione di stringhe ... forse passare a un ciclo for e usare la formattazione sarebbe meglio?

Sono sicuro che se AdmBorkBork tornasse, lo batterebbero molto: P

EDIT Capito il ciclo for e le sostituzioni, tutto grazie al mio predecessore :)

Vecchio tentativo:

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

Rubino, 41 39 byte

Una modifica di uno dei quines Ruby trovati qui .

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

Java 10, 194 byte

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

Spiegazione:

Provalo online (timeout dopo 60 sec).

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 stringa scontiene il codice sorgente non formattato.
• %sè usato per inserire questa stringa in se stessa con s.format(...).
• %c, %1$cE la 34vengono utilizzati per formattare le virgolette.
• s.format(s,34,s) mette tutto insieme

Parte sfida:

• for(;;) viene utilizzato per eseguire il ciclo indefinitamente.
• System.out.println(...) è usato per stampare con la nuova riga finale

Funky , 29 byte

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

Provalo online!

RProgN 2 , 7 byte

«]³]]p:

Provalo online!

Gelatina , 14 byte

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

Provalo online!

Pyth, 11 byte

#jN B"#jN B

Provalo qui!

Brachylog , 16 byte

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

Non puoi assolutamente provarlo online , ma ho verificato che funziona sulla mia installazione.

Brachylog , 18 byte

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

Provalo online!

Adattato dalla versione alternativa di questo quine , con un hack di backtracking che avevo inizialmente ideato per il bogosort di tutte le cose. Spende due byte ~nperché ẉ(i soliti mezzi per stampare con una nuova riga finale) risolvono alcuni problemi strani con la codifica dei caratteri su TIO e una nuova riga effettiva inserita nella stringa letterale viene stampata ~kcome \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.

Dato che w₁accetta l'input come un elenco [string to be formatted, formatting arguments], avvolgendo una stringa in un elenco e gconcatenandola a se stessa, jè possibile formattarla con se stessa. E poiché non viene fornito alcun input al programma, la variabile di input che è implicitamente presente all'inizio del programma può assumere qualsiasi valore, quindi può essere vincolata a una delle infinite liste che contengono "∋~kgjw₁⊥~n"come elemento, creando un singolo punto di scelta a cui tornare indietro quando dopo aver stampato la sua fonte il programma colpisce ⊥.

Python 3.6, 48 43 byte.

-5 byte grazie a @Jo King

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

Gol> <> , 10 byte

"r2sslRoao

Provalo online!

Questo può probabilmente essere risolto di più