Scrivi il codice più corto possibile che produce un output infinito.

È tutto. Il codice verrà squalificato solo se smette di produrre output ad un certo punto. Come sempre nel code golf, vince il codice più corto.

Ecco un elenco di risposte che penso siano davvero intelligenti, in modo che possano ottenere credito:

• La virgola è sia codice che dati
• Errori infiniti (che conta)
• Avvisi infiniti (che conta anche)
• Cos'è Marbelous?

Classifica

var QUESTION_ID=13152,OVERRIDE_USER=8611;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Befunge (1)

.

Produce 0per sempre. Funziona perché in Befunge le linee si avvolgono e ottieni 0se fai il pop dalla pila vuota.

x86 .COM eseguibile, 7

in esadecimale:

b8 21 0e cd 10 eb fc

Gli altri necessitano di kilobyte o più di librerie di sistema e runtime. Ritorno alle basi:

$ echo -ne '\xb8!\xe\xcd\x10\xeb\xfc' > A.COM
$ dosbox A.COM

È possibile modificare il 2o byte ( 0x21, o !) per modificare l'output.

Utilizza un interrupt BIOS per l'output; non ha bisogno di DOS, ma non ho installato QEMU.

Spiegazione

Il codice macchina corrisponde al seguente assieme:

        mov     ax, 0x0e21
again:  int     0x10
        jmp     again

L'output è tutto nella intchiamata - per questo riferimento , int 0x10 con 0x0e in AH stamperà il byte in AL sullo schermo.

Sapendo che il registro AX è una parola a 16 bit composta da AH nel byte alto e AL nel byte basso, possiamo salvare un carico aggiuntivo (e quindi un byte nel codice macchina) caricandoli insieme.

File batch di Windows, 2 caratteri

%0

Si chiama all'infinito.

Befunge 98 - 2

,"

Produce ",,,,,,,,,,," per l'eternità.

sh, 3 byte

yes

emette ycontinuamente

Haskell: 8 personaggi

Vecchio thread, ma è divertente

 fix show

in Haskell, stampa

\\\\\\\\\\\\\....

per sempre dal momento che è praticamente in esecuzione

 let x = show x in x

Sa che xè una stringa, quindi lo è il primo carattere ", quindi deve essere evitato \", ma sa che \deve essere evitato così \\\x, e così via e così via.

File batch di Windows, 8 caratteri

:a
goto a

Brainfuck, 4

+[.]

In alternativa,

-[.]

Java, 54 caratteri

Miglior tentativo in Java:

class A{static{for(int i=0;i<1;)System.out.print(1);}}

Bash, 4 byte

$0&$

Emette ./forever2.sh: line 1: $: command not foundcontinuamente.

Poiché $0è in background, ogni genitore muore dopo il comando non valido $, quindi lo stack / la memoria non viene consumato e questo dovrebbe continuare indefinitamente.

Stranamente l'output diventa sempre più lento nel tempo. topsegnala che l'utilizzo della CPU di sistema è prossimo al 100%, ma ci sono processi di memoria o CPU hog. Presumibilmente una certa allocazione delle risorse nel kernel diventa sempre meno efficiente.

LOLCODE (36)

HAI IZ 1<2? VISIBLE "0" KTHX KTHXBYE 

Pensato di dare una possibilità a LOLCODE, ha una quantità sorprendentemente grande di funzionalità.

JavaScript: 14

ATTENZIONE: non vuoi davvero eseguirlo nel tuo browser

for(;;)alert()

Turing Machine - 6 personaggi:

#s->1Rs

dove #è un simbolo vuoto (sul nastro per impostazione predefinita), sdescrive l'unico stato (iniziale) esistente, 1sta stampando una cifra, Rsignifica spostandosi a destra, salla fine rimane nello stesso stato.

Haskell, 10

print[1..]

Penso che questo sia il codice più breve per

1. Stampa qualcosa.
2. Crea una struttura di dati infinita Show: capace.

Per chi è interessato, stampa:

[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,...

Marbelous 4

24MB

Marbelous fa sorprendentemente bene qui. Questo invierà un numero infinito di segni di dollaro $, anche se colpirà il limite dello stack piuttosto rapidamente.

Come funziona.

24 è un linguaggio letterale, che cadrà dal tabellone e verrà stampato su STDOUT come corrispondente carattere ASCII. MB è il nome implicitamente assegnato alla scheda madre, poiché la scheda madre non ha input, genererà ogni tick. E poiché le celle vengono valutate da sinistra a destra, il valore letterale verrà sempre stampato prima della successiva chiamata ricorsiva.

Quindi questo equivale approssimativamente a questo pseudocodice:

MB() {
    print('$');
    while(true) MB();
}

Una soluzione senza ricorsione infinita 11

24@0
@0/\..

Questo funziona facendo circolare il letterale tra due portali @0, ogni volta che il 24 colpisce il basso @0viene trasportato nella cella sotto il superiore @0. Se atterra sul /\, che è un operatore clone, mette una copia del marmo (letterale) sulla sua sinistra (di nuovo sul portale) e un'altra alla sua destra. Questo coopy quindi cade dal tavolo (poiché ..è una cella vuota) e viene stampato su STDOUT. In pseudocodice, questo si tradurrebbe in:

MB() {
    while(true) print '$'
}

Una soluzione più breve senza ricorsione infinita 9

24
\\/\..

Questo lancia costantemente il marmo tra un clonatore e un deflettore, mettendo una copia sulla cella più a destra, da far cadere dal tabellone. In pseudocodice sarebbe simile a:

MB() {
    List charlist = ['$'];
    while(true) {
        charlist.add(charlist[0];
        charlist.add(charlist[0];
        charlist.pop();
        print(charlist.pop());
        // Wait, what?
    }
}

Nota

Le ..celle sono necessarie sulle ultime due schede poiché i marmi atterrerebbero fuori dalla scheda (e sarebbero scartati) altrimenti. Per un po 'di divertimento in più, sostituisci il 24marmo con FFe la ..cella vuota con un ??, che trasforma qualsiasi marmo in un marmo tra 0 e il suo valore attuale prima di farlo cadere. Indovina come sarebbe STDOUT.

C, 23 caratteri

Leggermente più breve della migliore risposta C / C ++ finora. Stampa linee vuote all'infinito (ma se compilato senza ottimizzazioni, trabocca lo stack).

main(){main(puts(""));}

Python 3: 15, 17 o 18 caratteri

La risposta di mdeitrick è più lunga in Python 3, che sostituisce l' printistruzione con una chiamata di funzione (15 caratteri):

while 1:print()

Questo rimane il più breve che ho trovato in Python 3. Tuttavia, ci sono alcuni modi più interessanti di stampare in un ciclo infinito che sono solo alcuni caratteri più lunghi.

• print()restituisce None, che! = 9, rendendolo un ciclo infinito; la 8è un no-op che sostituisce pass(18 caratteri):

  while print()!=9:8
  

• iter(print, 9)definisce un iterabile che restituisce l'output di print()fino a quando non è uguale 9(che non accade mai). anyconsuma l'input iterabile cercando un valore vero, che non arriva mai poiché print()ritorna sempre None. (Potresti anche usare setlo stesso effetto.)

  any(iter(print,9))
  

• Oppure, possiamo consumare l'iterabile verificando se contiene 8(17 caratteri):

  8in iter(print,9)
  

• Oppure, scompattalo usando l'operatore splat :

  *_,=iter(print,9)
  

• Il modo più strana ho pensato è quella di utilizzare splat destrutturazione all'interno di una chiamata di funzione, function(*iterable). Sembra che Python cerchi di consumare l'intero iterabile prima ancora di provare la chiamata di funzione, anche se la chiamata di funzione è falsa. Ciò significa che non abbiamo nemmeno bisogno di una vera funzione, perché l'errore di tipo verrà generato solo dopo che l'iterabile è esaurito (cioè mai):

  8(*iter(print,9))
  

piet - 3 codici

Emette un numero infinito di 1

x86 .COM eseguibile, 5 byte

in esadecimale:

40 CD 29 FF E6

in asm:

inc ax
int 0x29
jmp si

Spiegazione:

inc axincrementa il registro AX di uno. int 0x29è la routine "fast put char" di MSDOS, che genera semplicemente il valore in AL (la parte bassa di AX) e fa avanzare il cursore di uno. jmp siè solo un modo strano di tornare all'inizio, poiché il registro SI è 0x100 su quasi tutti i sistemi operativi simili a DOS, che è anche il punto di partenza di un programma .com;) È anche possibile fare un salto corto, che anche utilizza 2 byte.

fonti:

Valori iniziali MSDOS

Codifica WIKI

Bitxtreme , 0,25 byte

Rappresentazione binaria:

00

Dalla documentazione:

Il primo bit di ciascuna coppia è un puntatore alla posizione della memoria che contiene il valore da sottrarre dall'accumulatore. Il risultato viene memorizzato nella stessa posizione di memoria indicata dall'operando. Se il risultato è negativo (i bit sono nella rappresentazione del complemento a due), il secondo bit della coppia verrà aggiunto al PC corrente, modulo 2.

Il contatore del programma e l'accumulatore sono inizializzati a zero; quindi, il contenuto della posizione di memoria 0 viene sottratto dall'accumulatore. Questo sembra essere 0, lasciando l'accumulatore a zero. Poiché non è stato eseguito il carry, il secondo bit non viene aggiunto al contatore del programma.

Il contatore del programma viene quindi incrementato di 2 modulo 2, rimandandolo all'inizio e causando un ciclo infinito. Ad ogni passaggio, la posizione di memoria speciale 0 viene modificata, facendo sì che il suo contenuto (a 0) venga scritto sull'output.

Si può sostenere che questo programma dovrebbe essere valutato come 1 byte, perché l'interprete ufficiale in Python richiede zero-padding. Tuttavia, non penso che lo zero-padding sia davvero un codice .

Riepilogo: Ruby - 9, Golfscript - 6,> <> - 2, Whitespace - 19, Perl - 2

Una lingua che conosco e due che non ho mai usato prima: D
EDIT: Perl non ha funzionato quando ho installato Perl per provarlo :(

Ruby, 9

loop{p 1}

Stampa semplicemente 1 su righe separate continuamente.

Inoltre, un sacco di alternative:

loop{p''} # prints [ "" ]  on separate lines continually
loop{p p} # prints [ nil ] on separate lines continually

Soluzione da 10 caratteri:

p 1while 1

In realtà sono stato sorpreso di poter rimuovere lo spazio tra il primo 1e il while, ma a quanto pare funziona

Golfscript, 6

{1p}do

Il mio primo programma Golfscript! : P

> <> ( Pesce ), 2

1n

Spazio bianco , 19

lssslssstltlsslslsl

Dove srappresenta uno spazio, trappresenta una scheda e lun avanzamento riga.

C, 25 24

main(){main(puts("1"));}

> <> (Pesce) , 2

Un modo creativo per usare la codebox infinita di pesci:

"o

Poiché il puntatore dell'istruzione ritorna all'inizio della riga dopo aver raggiunto la fine, questo codice può essenzialmente essere letto come

"o"o

il che significa 'leggi la stringa "o" e poi l'output'.

Puoi testare il codice qui

perl, 10 caratteri

Ecco un'altra soluzione da 10 caratteri perl con alcuni compromessi diversi. In particolare, non richiede l'avvio del flag -n o dell'input dell'utente. Tuttavia, continua a mangiare memoria all'infinito.

warn;do$0

salvare in un file, eseguire quel file e si ottiene ad esempio:

Warning: something's wrong at /tmp/foo.pl line 1.
Warning: something's wrong at /tmp/foo.pl line 1.
Warning: something's wrong at /tmp/foo.pl line 1.

dc , 7

[pdx]dx

stampa 'pdx \ n' infinitamente molte volte.

VBA: 12

L'audio viene emesso, giusto?

do:beep:loop

Inseriscilo nel file MS Office preferito dai tuoi collaboratori preferito dai macro per un po 'di divertimento!

Private Sub Workbook_Open()
    Do:Beep:Loop
End Sub

Punti bonus se usano le cuffie.

Seme , 4 byte

99 5

Provalo online! Emette 11all'infinito

Genera il seguente programma Befunge-98:

[glzgx"Lz^v*M7TW!4:wi/l-[, s44~s;|Sa3zb|u<B/-&<Y a@=nN>Nc%}"gq!kCW $1{2hyzABRj*glr#z(@Zx@xT=>1'.b
/

Provalo online!

La parte rilevante è proprio questa:

[>1'.b
/

bspinge 11verso la pila e la .stampa. 1e 49vengono anche spinti in pila, ma mai effettivamente stampati.

Animazione del codice in esecuzione:

C, 26 25 24 (nessuna ricorsione)

main(){for(;;puts(""));}

Stampa infiniti '\n'personaggi. Questo è un byte più lungo della risposta C più breve, ma non si basa sull'ottimizzazione delle chiamate di coda per evitare di traboccare lo stack.

R, 13 caratteri

repeat cat(1)

PowerShell 2.0: 17 11 8

La mia soluzione iniziale:

while(1 -eq 1){1}

Grazie a res:

while(1){1}

Penso che Danko Durbić abbia il vincitore, qui. Non sono nemmeno sicuro del perché questo dovrebbe funzionare, ma funziona e non riesco a pensare a niente di più breve finora.

for(){1}