Il tuo compito è creare il ciclo infinito più breve!

Il punto di questa sfida è creare un loop infinito che non produca output, a differenza del suo possibile duplicato. Il motivo è che il codice potrebbe essere più breve se non viene fornito alcun output.

Regole

• Ogni invio deve essere un programma completo.
• È necessario creare il ciclo infinito più breve.
• Anche se alla fine il tuo programma esaurisce la memoria, viene comunque accettato fintanto che è in esecuzione tutto il tempo dall'inizio alla fine della memoria. Inoltre, quando esaurisce la memoria, non dovrebbe ancora stampare nulla su STDERR.
• Il programma non deve ricevere input (tuttavia, è consentita la lettura da un file) e non deve stampare nulla su STDOUT. È vietato anche l'output in un file.
• Il programma non deve scrivere nulla su STDERR.
• Sentiti libero di usare una lingua (o versione linguistica) anche se è più recente di questa sfida. -Nota che ci deve essere un interprete in modo che la presentazione possa essere testata. È permesso (e persino incoraggiato) di scrivere questo interprete per una lingua precedentemente non implementata. : D
• Le iscrizioni vengono classificate in byte, con una codifica appropriata (preesistente), solitamente (ma non necessariamente) UTF-8. Alcune lingue, come Cartelle, sono un po 'difficili da segnare - in caso di dubbi, si prega di chiedere su Meta.
• Non si tratta di trovare la lingua con il programma a ciclo infinito più breve. Si tratta di trovare il programma a ciclo infinito più breve in ogni lingua. Pertanto, non accetterò una risposta.
• Se la tua lingua preferita è una variante banale di un'altra lingua (potenzialmente più popolare) che ha già una risposta (pensa a dialetti BASIC o SQL, shell Unix o banali derivati ​​Brainf ** k come Alphuck), considera di aggiungere una nota all'esistente rispondere che la stessa o una soluzione molto simile è anche la più breve nell'altra lingua.
  
• Dovrebbe esserci un sito web come Wikipedia, Esolangs o GitHub per la lingua. Ad esempio, se la lingua è CJam, si potrebbe collegare al sito nell'intestazione come #[CJam](http://sourceforge.net/p/cjam/wiki/Home/), X bytes.
• Non sono ammesse scappatoie standard.

(Ho preso alcune di queste regole dalla sfida "Hello World" di Martin Büttner)

Non esitate a postare nei commenti per dirmi come questa sfida potrebbe essere migliorata.

Catalogare

Questo è un frammento di stack che genera sia un catalogo alfabetico delle lingue utilizzate, sia una classifica generale. Per assicurarti che la tua risposta venga visualizzata, avviala con questa intestazione Markdown:

# Language name, X bytes

Ovviamente sostituendo Language namee X bytescon gli articoli adeguati. Se vuoi collegarti al sito web delle lingue, usa questo modello, come pubblicato sopra:

#[Language name](http://link.to/the/language), X bytes

Ora, finalmente, ecco lo snippet: (Prova a premere "Pagina intera" per una visione migliore.)

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

body{text-align:left!important}#answer-list{padding:10px;width:500px;float:left}#language-list{padding:10px;padding-right:40px;width:500px;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="language-list"> <h2>Shortest Solution 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> <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> <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 , 0 byte

Sì. Esiste un programma Befunge in un campo di gioco bidimensionale con dimensioni fisse che avvolgono i bordi. Con nulla in quello spazio per interferire, il contatore del programma viene eseguito in un ciclo infinito per impostazione predefinita :)

L00P , 0 byte

Questo lang è stato creato per il looping ed è proprio quello che farà ...

Codice macchina C64 , 2 byte

D0 FE

Si ramifica su se stesso se il flag zero non è impostato.

I rami sono offset a byte singolo dalla posizione dell'istruzione successiva e 254 è -2 nel complemento a due ... l'istruzione BNE (D0) occupa un byte di memoria e l'offset prende un secondo byte, quindi ramificando due byte indietro rami indietro a se stesso. Il flag zero viene sempre cancellato quando il codice viene caricato in memoria.

Si noti che questa non è una chiamata di subroutine ricorsiva, quindi non si esaurirà mai la memoria. Si noti inoltre che non esiste intestazione, compilatore o overhead eseguibile ... è davvero un programma a due byte :)

Brainfuck, 3 byte

+[]

Non diminuire mai: non finire mai.

/// , 3 byte

///

Qualche punto bonus per l'utilizzo del nome della lingua come codice sorgente?

Java , 53 byte

class A{public static void main(String[]a){for(;;);}}

Yay requisito di programma completo!

Prolog, 5 byte

a:-a.

Per sapere se il predicato aè vero, devi solo verificare se il predicato aè vero.

_{Devi caricare il file ed eseguirlo a, entrambi con argomenti da riga di comando. Si noti che è probabile che la ricorsione sia ottimizzata come un ciclo infinito e non dovrebbe far saltare lo stack.}

Inoltre, questo sembra uno smiley, ma non sono sicuro di come chiamarlo. Il punto sembra saliva, quindi forse "stato vegetativo", o "programmatore con capelli ricci". Suggerimenti sono ben accetti

Haskell , 9 byte

Ricorsione infinita della funzione principale. Dovrebbe essere compilato in un ciclo a causa dell'ottimizzazione della ricorsione della coda.

main=main

Python, 9 byte

Funziona in 2 e 3.

while 1:0

Ridotto da @FryAmTheEggman

eseguibile ELF x86, 45 byte

A differenza della stragrande maggioranza di queste risposte, questo è un programma veramente completo, come in un programma eseguibile indipendente.

00000000: 7f45 4c46 0100 0000 0000 0000 0000 0100  .ELF............
00000010: 0200 0300 2000 0100 2000 0100 0400 0000  .... ... .......
00000020: ebfe 31c0 40cd 8000 3400 2000 01         ..1.@...4. ..

Le viscere del programma sono al byte 0x20 ebfe, che è descritto in un'altra risposta come il più piccolo programma NASM. Se invece lo assembli con NASM, otterrai un eseguibile con migliaia di byte non necessari. Possiamo sbarazzarci della maggior parte di loro usando la tecnica descritta qui . Si può notare che questo programma non è nemmeno grande come l'intestazione ELF! Questo bit di golf eseguibile malforma l'intestazione ELF e l'intestazione del programma in modo che possano occupare gli stessi byte nel file e inserisce il nostro programma in alcuni byte non utilizzati all'interno dell'intestazione. Linux leggerà ancora felicemente l'intestazione e avvierà l'esecuzione in offset 0x20dove gira per sempre.

INTERCAL, 42 18 byte

(1)DO COME FROM(1)

Idea presa dal commento di @ flawr.

EDIT: Holy merda, INTERCAL è in realtà più breve di C #. Non so se sia mai successo prima ...

Versione a 42 byte

DO(1)NEXT
(1)DO FORGET #1
PLEASE DO(1)NEXT

Perl , 6 byte

perl -e '{redo}'

Da perldoc -f redo:

Il comando redo riavvia il blocco loop senza rivalutare nuovamente il condizionale ... Notare che un blocco da solo è semanticamente identico a un loop che viene eseguito una volta. Quindi ripetere all'interno di un tale blocco lo trasformerà effettivamente in un costrutto loop.

Non vedo redotroppo spesso nel codice di produzione, ma è ottimo per il golf! Confrontare la sopra per gli equivalenti più brevi con for, whilee goto:

for(;;){} # 9 bytes
1while 1  # 8 bytes
X:goto X  # 8 bytes

> <> , 1 byte

Un singolo spazio farà sì che <<> vada in un ciclo infinito di NOP

Altri programmi validi a carattere singolo (senza requisiti di memoria) sono i seguenti:

>^v</\|_#x!"'{}r

Inoltre, le regole stabiliscono che il tuo programma può esaurire la memoria, nel qual caso possiamo aggiungere i seguenti caratteri all'elenco dei programmi validi a 1 byte:

01234567890abcdefli

Motorola MC14500B Codice macchina , 0,5 0 byte

Spiegazione

Secondo il manuale, il sistema è configurato per avere una struttura di controllo ad anello. Il contatore del programma conta fino al suo valore più alto, torna indietro a zero e conta di nuovo.

LOLCODE , 24 byte

IM IN YR X
IM OUTTA YR X

C, 15 byte

main(){main();}

Sì, è possibile chiamare in main()modo ricorsivo. Se hai un compilatore che esegue l'ottimizzazione delle chiamate di coda (diciamo, gcc con l' -O2opzione), non è nemmeno segfault: il compilatore è abbastanza intelligente da trasformare la chiamata di funzione in a goto.

Labirinto , 1 byte

"

Un programma labirinto esegue ripetutamente le stesse istruzioni se non ci sono vicini. Inoltre non finiranno fino a quando non eseguiranno l' @istruzione.

Vim , 7 sequenze di tasti

Apri l'editor, preferibilmente senza script caricati, ad esempio in questo modo dalla riga di comando: vim -u NONE

qq@qq@q

Vimscript, 15 8 byte

Aggiungilo in uno script o eseguilo direttamente :premendo prima il tasto due punti ( ) mentre sei in modalità normale

wh1|endw

Retina , 3 byte

+`0

Se viene fornito un singolo file, Retina utilizza una fase Count, sostituendo l'input con il numero di corrispondenze trovate per la regex specificata. Qui, la regex è 0. Ora +passa in rassegna il palco fino a quando il risultato cambia dalla precedente iterazione. Cosa sta succedendo esattamente?

• 0viene confrontato con l'input vuoto, fornendo zero corrispondenze, quindi il risultato è 0. Questo è diverso dall'input, quindi lo eseguiamo di nuovo.
• 0viene confrontato con l'output precedente 0, che ora fornisce una corrispondenza ... quindi il risultato è 1.
• 0viene confrontato con l'output precedente 1, che non riesce ... quindi il risultato è 0.
• ... hai avuto l'idea.

Il risultato dell'iterazione del ciclo si alterna tra 0e 1, il che a) assicura che il ciclo non si interrompa mai eb) assicura che non stiamo esaurendo la memoria perché la stringa non cresce.

Per impostazione predefinita, Retina emette solo una volta terminato il programma, quindi questo non stampa nulla (è possibile modificare questo comportamento aggiungendo un >dopo il +, che quindi stamperà gli zero e quelli alternati ).

A partire da 1.0, Retina in realtà ha anche più tradizionali cicli di ciclo, che potresti usare con uno stadio più semplice (che non cambia la stringa tutto il tempo), ma in realtà richiedono più byte. Un'opzione sarebbe:

//+`

BASIC (QBasic 4.5), 10 5 3 byte

Nel linguaggio di programmazione BASIC, RUN viene utilizzato per avviare l'esecuzione del programma dalla modalità diretta o per avviare un programma overlay da un programma caricatore. - Wikipedia

Modifica: funziona senza un numero di riga in QBasic 4.5, secondo @steenbergh

RUN

Ecco la prima versione che ho pubblicato. Ciclo GOTO infinito. Inoltre, sono 10 byte, che è una bella coincidenza!

10 GOTO 10

Tipo di nodo TIS Architettura T21, 6 byte

I nodi del sistema di intelligenza a mosaico sono classificati come nodi "elaborazione" o "archiviazione". I nodi di archiviazione semplicemente archiviano e recuperano informazioni e in questo caso sono irrilevanti. Restano i nodi di elaborazione. Il tipo di nodo T21, o nodo di esecuzione di base, è il più comune e semplice (come suggerisce il nome).

Tecnicamente, ogni nodo può essere pensato come un computer indipendente. Nel caso del T21, si tratta di un computer che ha due registri di archiviazione (uno indirizzabile, uno no) e un set di istruzioni di 15 comandi. Ha memoria sufficiente per essere programmato con un massimo di 15 istruzioni. Tutti i nodi TIS hanno quattro porte che li collegano ai nodi topologicamente adiacenti. La lettura da una porta fa sì che quel nodo si blocchi fino a quando il nodo sull'altra estremità non scrive su di esso e la scrittura su una porta si blocca fino a quando quel nodo non lo legge.

Ormai potresti essere in grado di dire che i nodi TIS non sono mai stati pensati per fare molto da soli. Insieme, però, possono essere piuttosto potenti ... beh, per il loro tempo. A causa di queste limitazioni, è molto raro vedere qualcuno usare solo un singolo nodo. In effetti, un programma che accetta input e fornisce output basato su di esso deve utilizzare almeno tre nodi, poiché i sistemi TIS immettono input nella UPporta di un nodo nella riga superiore e prendono output dalla DOWNporta di un nodo nella riga inferiore. Ci sono tre righe, quindi i dati devono passare attraverso almeno tre nodi per arrivare in fondo.

A causa di queste limitazioni, i nodi TIS sono generalmente utilizzati in questo modo:

1. Ottieni input
2. Fai qualcosa
3. Trasmetterla
4. Torna al passaggio 1

Per questo motivo, lo spazio limitato per le istruzioni e il fatto che i nodi semplicemente attendono in silenzio e non causano problemi quando si tenta di leggere input che non sono presenti, è stata presa una decisione nel loro design che li rende molto buoni per questa sfida. Citerò dal manuale di riferimento del TIS-100:

Dopo aver eseguito l'ultima istruzione del programma, l'esecuzione continua automaticamente alla prima istruzione.

Perfetto! I loop infiniti sono predefiniti per i nodi TIS.

Ho quasi risposto a questa domanda con una risposta di 0 byte, sostenendo che un nodo vuoto era un ciclo infinito. Tuttavia, ho studiato ulteriormente. Innanzitutto, la citazione sopra afferma che il ciclo si verifica dopo aver eseguito l'ultima istruzione . Inoltre, ho testato l'implementazione. Ogni nodo riporta una "modalità" in ogni momento. Non è accessibile a livello di codice ma è progettato per facilitare il debug. Ecco le possibili modalità:

 RUN‌ - I am executing an instruction.
READ - I am reading from a port, waiting for it to be written to.
WRTE - I am writing to a port, waiting for it to be read from.
IDLE - I am doing nothing.

Si scopre che, poiché ogni nodo è un singolo computer, sono in grado di determinare se dispongono o meno di istruzioni da eseguire. In caso contrario, rimangono nello IDLEstato (probabilmente per risparmiare energia). In quanto tale, non potevo in buona coscienza affermare che fosse "looping"; piuttosto, ogni nodo sedeva in silenzio, supponendo che gli altri stessero facendo qualcosa di importante.

Questo programma che ho inviato è davvero un ciclo infinito, poiché eseguendolo imposta lo stato del nodo su RUN. È semplice come ci si aspetterebbe, NOPeseguire No OPerazione. Una volta fatto fare nulla, l'esecuzione torna al superiore del codice: NOP.

Se lo trovate insoddisfacente che sto abusando l'architettura T21 per creare un ciclo, mi offrono una soluzione alternativa al costo di 2 byte: JRO 0. JROsignifica Jump Relativo Oincondizionatamente. O qualcosa del genere, immagino. Non esiste una forma estesa concordata delle istruzioni. Ad ogni modo, JROaccetta un argomento numerico e salta l'esecuzione di tale importo rispetto alla posizione corrente. Ad esempio, JRO 2salta l'istruzione che la segue (utile se l'istruzione viene saltata da un'altra parte). JRO 1salta avanti di un'istruzione, rendendola a NOP. JRO -1salta indietro di un'istruzione, eseguendo efficacemente l'istruzione precedente una volta ogni due cicli fino a quando il programma viene arrestato. Ed ovviamente,JRO 0 salta su se stesso, eseguendosi per sempre.

A questo punto potresti pensare:

Certo, monorotaia, tutto questo ha senso, ma la tua risposta è semplice NOP. Perché il suo punteggio è di 6 byte?

Bella domanda, grazie per avermelo chiesto. Si può ingenuamente pensare che i programmi TIS debbano essere contati nello stesso modo in cui contiamo i programmi in più file: il numero di byte in tutti i nodi, più 1 byte per ciascun nodo aggiuntivo dopo il primo. Tuttavia, la comunità del golf TIS ha deciso che ciò sarebbe ingiusto per il semplice motivo che ignora alcune delle informazioni richieste per ricreare le soluzioni. I vicini di un nodo sono molto importanti e quel metodo di punteggio ti fornisce informazioni di posizione gratuitamente. Al contrario, abbiamo adottato il formato utilizzato dal più comune emulatore TIS, il TIS-100 dal nome confuso. (Nota a margine: per favore non nominare gli emulatori in base al sistema che emulano. Non è intelligente, è solo fastidioso e fa sì che tutti debbano chiarire costantemente di cosa stanno parlando.) È molto semplice: i 12 nodi di un TIS-100 i dispositivi sono numerati, da sinistra a destra e dall'alto verso il basso, saltando tutti i nodi di archiviazione installati dal sistema emulato. Un nodo numerato Ncontenente # CODE\n# CODE\n CODEviene salvato in questo modo:

@N
# CODE
# CODE
# CODE

E così, un nodo numerato 0 contenente NOPè segnato secondo la sua rappresentazione in questo formato:

@0
NOP

Sei byte.

Come spesso includo nelle mie risposte in lingue visivamente interessanti, puoi guardare l'emulatore TIS-100 eseguire questo programma su YouTube . Tuttavia, considerando quale sia questa sfida, non so cosa ti aspetti di vedere ...

C # , 38 37 36 byte

class B{static int Main(){for(;;);}}

Per loop senza condizioni di arresto.

Il ritorno di main dovrebbe essere un int, ma dal momento che non raggiungerà mai la fine questo dovrebbe compilare. (Testato in VS 2015 e 2013, funziona anche in Ideone ). Grazie Geobits e MichaelS .

È possibile ottenere una versione più breve, 35 byte, ma le stampe Process is terminated due to StackOverflowExceptionche a mio avviso violano il terzo punto di non stampare nulla su stderr. Ringraziamo MichaelB

class B{static int Main()=>Main();}

Foo, 3 byte

(1)

Il linguaggio di programmazione preferito da tutti! : D

Esagonia , 1 byte

.

Non so molto di questo fantastico linguaggio creato da @ MartinBüttner, ma da quello che ho visto, questo dovrebbe ripetersi all'infinito, poiché non c'è modo @di fermare il programma. .è semplicemente una no-op.

Perl, 4 byte

do$0

Si esegue ripetutamente.

Gammaplex , 0 byte

In Gammaplex, non è possibile scrivere un programma che non sia un ciclo infinito. Quindi scrivo solo un programma che non utilizza input / output.

Pyth, 2 byte

# 

Pyth si aspetta token dopo l'operatore forever. (Quello è uno spazio.)

bash + coreutils BSD, 23 22 14 6 5 6 byte

yes>&-

yesgenera "y" per sempre; >&-chiude STDOUT.

Grazie @Dennis e @ThisSuitIsBlackNot per l'aiuto nel ridurre le dimensioni!

Lisp comune, 6 personaggi

(loop)

Fissione , 1 byte

Esistono esattamente 4 soluzioni a un byte:

R

L

U

D

Queste quattro lettere indicano che un atomo inizia lì (nella direzione corrispondente). Uno di questi è necessario perché senza un atomo il programma termina immediatamente. Poiché il codice sorgente ha solo un carattere, l'atomo si avvolgerà immediatamente ed eseguirà di nuovo la stessa cella. Tuttavia, dopo l'inizio del programma è UDLRsufficiente agire per deviare un atomo in arrivo nella direzione corrispondente, quindi in questo caso diventano no-ops.