Votre tâche est de créer la boucle infinie la plus courte!

Le but de ce défi est de créer une boucle infinie ne produisant aucune sortie, contrairement à sa duplication possible. La raison en est que le code peut être plus court si aucune sortie n'est donnée.

Règles

• Chaque soumission doit être un programme complet.
• Vous devez créer la boucle infinie la plus courte.
• Même si votre programme finit par manquer de mémoire, il est toujours accepté tant qu'il est exécuté du début à la fin. Aussi, quand il manque de mémoire, il ne devrait toujours rien imprimer sur STDERR.
• Le programme ne doit prendre aucune entrée (toutefois, la lecture d'un fichier est autorisée) et ne doit rien imprimer dans STDOUT. La sortie dans un fichier est également interdite.
• Le programme ne doit rien écrire dans STDERR.
• N'hésitez pas à utiliser une langue (ou une version linguistique) même si c'est plus récent que ce défi. -Notez qu'il doit y avoir un interprète pour que la soumission puisse être testée. Il est permis (et même encouragé) d’écrire cet interprète vous-même pour une langue non encore implémentée. :RÉ
• Les soumissions sont notées en octets, dans un codage approprié (préexistant), généralement (mais pas nécessairement) UTF-8. Certaines langues, comme les dossiers, sont un peu difficiles à noter - en cas de doute, demandez-les sur Meta.
• Il ne s'agit pas de trouver la langue avec le programme de boucle infini le plus court. Il s’agit de trouver le programme de boucle infini le plus court dans toutes les langues. Par conséquent, je n'accepterai pas de réponse.
• Si votre langue de choix est une variante triviale d'une autre langue (potentiellement plus populaire) qui possède déjà une réponse (pensez aux dialectes BASIC ou SQL, aux shells Unix ou aux k-dérivés triviaux de Brainf ** tels qu'Alphuck), envisagez d'ajouter une note au texte existant. répondez que la même solution ou une solution très similaire est également la plus courte dans l’autre langue.
  
• Il devrait y avoir un site Web tel que Wikipedia, Esolangs ou GitHub pour la langue. Par exemple, si le langage est CJam, vous pouvez créer un lien vers le site dans l’en-tête, par exemple #[CJam](http://sourceforge.net/p/cjam/wiki/Home/), X bytes.
• Les failles standard ne sont pas autorisées.

(J'ai repris certaines de ces règles du défi "Hello World" de Martin Büttner)

N'hésitez pas à poster dans les commentaires pour me dire comment ce défi pourrait être amélioré.

Catalogue

Il s'agit d'un extrait de pile qui génère à la fois un catalogue alphabétique des langues utilisées et un classement général. Pour vous assurer que votre réponse apparaît, commencez-la avec cet en-tête Markdown:

# Language name, X bytes

Évidemment remplacer Language nameet X bytesavec les articles appropriés. Si vous souhaitez créer un lien vers le site Web des langues, utilisez ce modèle, comme indiqué ci-dessus:

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

Maintenant, enfin, voici l'extrait: (Essayez d'appuyer sur "Page entière" pour une meilleure vue.)

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 octet

Ouaip. Un programme Befunge existe dans un champ de jeu en deux dimensions avec une taille fixe qui enveloppe les bords. En l'absence d'interférence dans cet espace, le compteur de programme s'exécute par défaut dans une boucle infinie :)

L00P , 0 octet

Ce langage a été conçu pour la boucle, et c'est exactement ce que ça va faire ...

Code machine C64 , 2 octets

D0 FE

Se branche à lui-même si l'indicateur zéro n'est pas défini.

Les branches sont des décalages d'un octet par rapport à l'emplacement d'instruction suivant, et 254 correspond à -2 en complément de deux ... l'instruction BNE (D0) utilise un octet de mémoire et l'offset utilise un deuxième octet. à lui-même. L'indicateur de zéro est toujours effacé lorsque le code est chargé en mémoire.

Notez qu'il ne s'agit pas d'un appel de sous-routine récursif, vous ne manquerez donc jamais de mémoire. Notez également qu’il n’ya pas d’en-tête, de compilateur ou de surcharge exécutable ... c’est vraiment un programme à deux octets :)

Brainfuck, 3 octets

+[]

Ne décrémentez jamais: ne finissez jamais.

/// , 3 octets

///

Des points supplémentaires pour utiliser le nom de la langue comme code source?

Java , 53 octets

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

Yay l'exigence complète du programme!

Prolog, 5 octets

a:-a.

Pour savoir si le prédicat aest vrai, il vous suffit de vérifier si le prédicat aest vrai.

_{Vous devez charger le fichier et l'exécuter aavec une argumentation en ligne de commande. Notez que la récursion est susceptible d'être optimisée en tant que boucle infinie et ne doit pas détruire la pile.}

En outre, cela ressemble à un smiley, mais je ne sais pas comment l'appeler. Le point ressemble à de la salive, alors peut-être «état végétatif» ou «programmeur infiuré aux cheveux bouclés». Les suggestions sont les bienvenues.

Haskell , 9 octets

Récursion infinie de la fonction principale. Devrait être compilé dans une boucle en raison de l'optimisation de la récursion de la queue.

main=main

Python, 9 octets

Fonctionne en 2 et 3.

while 1:0

Raccourci par @FryAmTheEggman

x86 ELF exécutable, 45 octets

Contrairement à la grande majorité de ces réponses, il s’agit d’un programme véritablement complet, comme dans un programme exécutable autonome.

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

Les entrailles du programme sont à l' octet 0x20 ebfe, qui est présenté dans une autre réponse que le programme MSNA plus petit. Si vous assemblez cela avec NASM, vous obtenez un exécutable avec des milliers d'octets inutiles. Nous pouvons nous débarrasser de la plupart d'entre eux en utilisant la technique décrite ici . Vous pouvez noter que ce programme n’est même pas aussi gros que l’en-tête ELF! Ce morceau de golf exécutable malforme l'en-tête ELF et l'en-tête du programme, de sorte qu'ils puissent occuper les mêmes octets dans le fichier et insère notre programme dans des octets inutilisés de l'en-tête. Linux sera toujours heureux de lire l’en-tête et de commencer l’exécution avec décalage 0x20où il tourne pour toujours.

INTERCAL, 42 à 18 octets

(1)DO COME FROM(1)

Idée tirée du commentaire de @ flawr.

MODIFIER: Merde, INTERCAL est en fait plus court que C #. Je ne sais pas si c'est déjà arrivé avant ...

Version de 42 octets

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

Perl , 6 octets

perl -e '{redo}'

De perldoc -f redo:

La commande redo redémarre le bloc de boucle sans évaluer à nouveau la conditionnelle ... Notez qu'un bloc est sémantiquement identique à une boucle qui s'exécute une fois. Ainsi, refaire l'intérieur d'un tel bloc le transformera effectivement en une construction en boucle.

Je ne vois pas redotrop souvent dans le code de production, mais c'est bien pour le golf! Comparez ce qui précède les plus courts équivalents avec for, whileet goto:

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

> <> , 1 octet

Un seul espace entraînera> <> dans une boucle infinie de NOP

Les autres programmes à caractère unique valides (sans mémoire requise) sont les suivants:

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

De plus, les règles indiquent que votre programme peut manquer de mémoire, auquel cas nous pouvons ajouter les caractères suivants à la liste des programmes à 1 octet valides:

01234567890abcdefli

Motorola MC14500B Code machine , 0.5 0 octets

Explication

Selon le manuel, le système est configuré pour avoir une structure de contrôle en boucle. Le compteur de programme compte jusqu'à sa valeur la plus élevée, revient à zéro et compte à nouveau.

LOLCODE , 24 octets

IM IN YR X
IM OUTTA YR X

C, 15 octets

main(){main();}

Oui, il est possible d'appeler de main()manière récursive. Si vous avez un compilateur qui optimise les appels différés (par exemple, gcc avec l' -O2option), il ne se distingue même pas par une erreur de segmentation: le compilateur est suffisamment intelligent pour transformer l'appel de fonction en un fichier goto.

Labyrinthe , 1 octet

"

Un programme labrinth exécute la même instruction encore et encore s'il n'y a pas de voisins. Ils ne finiront pas non plus jusqu'à ce qu'ils exécutent l' @instruction.

Vim , 7 frappes

Ouvrez l'éditeur, de préférence sans scripts chargés, par exemple comme ceci depuis la ligne de commande: vim -u NONE

qq@qq@q

Vimscript, 15 8 octets

Ajoutez-le dans un script ou exécutez-le directement en :appuyant d'abord sur la touche deux-points ( ) en mode normal

wh1|endw

Rétine , 3 octets

+`0

Si un seul fichier est donné, Retina utilise une étape Count, remplaçant l'entrée par le nombre de correspondances trouvées pour la regex donnée. Ici, la regex est 0. +Boucle maintenant l'étape tant que le résultat change par rapport à l'itération précédente. Alors qu'est-ce qui se passe exactement?

• 0est comparé à l'entrée vide, ne donnant aucune correspondance, le résultat est donc 0. Ceci est différent de l'entrée, donc nous l'exécutons à nouveau.
• 0est comparé à la sortie précédente 0, ce qui donne maintenant une correspondance ... le résultat est donc 1.
• 0correspond à la sortie précédente 1, ce qui échoue ... le résultat est donc 0.
• ... vous avez eu l'idée.

Le résultat de l'itération de la boucle alterne entre 0et 1, ce qui garantit a) que la boucle ne se termine jamais et b) garantit que nous ne manquons pas de mémoire car la chaîne ne grossit pas.

Par défaut, Retina ne sort que lorsque le programme est terminé, ainsi cela n’imprime rien (vous pouvez changer ce comportement en ajoutant un >après le +, qui affichera ensuite les zéros et les uns en alternance ).

À partir de la version 1.0, Retina propose également des boucles While plus traditionnelles, que vous pouvez utiliser avec une étape plus simple (qui ne modifie pas la chaîne en permanence), mais qui nécessitent en réalité davantage d'octets. Une option serait:

//+`

BASIC (QBasic 4.5), 10 5 3 octets

Dans le langage de programmation BASIC, RUN est utilisé pour démarrer l'exécution du programme à partir du mode direct ou pour démarrer un programme en superposition à partir d'un programme de chargement. - Wikipedia

Edit: Cela fonctionne sans numéro de ligne dans QBasic 4.5, selon @steenbergh

RUN

Voici la première version que j'ai postée. Boucle infinie de GOTO. En outre, c'est 10 octets, ce qui est une belle coïncidence!

10 GOTO 10

Type de nœud TIS, architecture T21, 6 octets

Les nœuds du système de renseignement Tessellated sont classés en tant que nœuds de "traitement" ou de "stockage". Les nœuds de stockage stockent et récupèrent simplement des informations et ne sont pas pertinents dans ce cas. Restant sont les nœuds de traitement. Le type de nœud T21, ou nœud d'exécution de base, est le plus commun et le plus simple (comme son nom l'indique).

Techniquement, chaque nœud peut être considéré comme un ordinateur indépendant. Dans le cas du T21, il s’agit d’un ordinateur doté de deux registres de stockage (un adressable, un non) et d’un jeu d’instructions de 15 commandes. Il a suffisamment de mémoire pour être programmé avec 15 instructions maximum. Tous les nœuds TIS ont quatre ports qui les connectent aux nœuds topologiquement adjacents. La lecture d'un port provoque le blocage de ce nœud jusqu'à ce que le nœud de l'autre extrémité l'écrive, et l'écriture sur un port se bloque jusqu'à ce que ce nœud le lise.

Vous êtes peut-être en mesure de dire maintenant que les nœuds TIS n'ont jamais été conçus pour faire grand-chose par eux-mêmes. Ensemble, cependant, ils peuvent être assez puissants… enfin, pour leur temps. En raison de ces limitations, il est très rare de voir quelqu'un n'utiliser qu'un seul nœud. En fait, un programme qui prend une entrée et fournit une sortie en fonction de celle-ci doit utiliser au moins trois nœuds, car les systèmes TIS alimentent le UPport d'un nœud sur la rangée supérieure et prennent la sortie du DOWNport d'un nœud sur la rangée inférieure. Il y a trois lignes, donc les données doivent passer par au moins trois nœuds pour atteindre le bas.

En raison de ces limitations, les nœuds TIS sont généralement conçus comme suit:

1. Obtenir des commentaires
2. Faire quelque chose
3. Passe le
4. Revenir à l'étape 1

Pour cette raison, l'espace limité pour les instructions et le fait que les noeuds attendent simplement et ne posent aucun problème lorsque vous essayez de lire des entrées absentes, une décision a été prise dans leur conception, ce qui les rend très utiles pour ce défi. Je citerai le manuel de référence du TIS-100:

Après l'exécution de la dernière instruction du programme, l'exécution continue automatiquement à la première instruction.

Parfait! Les boucles infinies sont les valeurs par défaut pour les nœuds TIS.

J'ai presque répondu à cette question avec une réponse de 0 octet, affirmant qu'un nœud vide était une boucle infinie. Cependant, j'ai cherché plus loin. Premièrement, la citation ci-dessus indique que la boucle se produit après l'exécution de la dernière instruction . De plus, j'ai testé l'implémentation. Chaque nœud signale un "mode" à tout moment. Il n'est pas accessible par programme, mais il est conçu pour faciliter le débogage. Voici les modes possibles:

 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.

Comme chaque nœud est un ordinateur individuel, il est en mesure de déterminer s’il a ou non des instructions à exécuter. Sinon, ils restent dans leIDLE état (susceptibles d'économiser de l'énergie). En tant que tel, je ne pouvais pas, en toute conscience, prétendre que cela "tournait en boucle"; au lieu de cela, chaque nœud était assis en silence, supposant que les autres faisaient quelque chose d'important.

Ce programme que j'ai soumis est vraiment une boucle infinie, car son exécution définit l'état du nœud sur RUN. Il est aussi simple que vous attendez, NOPexécute No OPration. Une fois qu'il a fait ne rien faire, l' exécution revient au haut du code: NOP.

Si vous trouvez qu'il est peu satisfaisant que j'abuser de l'architecture T21 pour créer une boucle, je vous offre une solution de rechange au coût de 2 octets: JRO 0. JROdes moyens JUMP Runc élatif Onditionally. Ou quelque chose, je suppose. Il n'y a pas de forme élargie convenue des instructions. Quoi qu'il en soit, JROprend un argument numérique et exécute l'exécution de ce montant par rapport à la position actuelle. Par exemple, JRO 2ignore l'instruction qui la suit (utile si cette instruction est appelée ailleurs). JRO 1fait un saut en avant d’une instruction, ce qui en fait un NOP. JRO -1revient en arrière d'une instruction et exécute effectivement l'instruction précédente une fois tous les deux cycles jusqu'à ce que le programme soit arrêté. Et bien surJRO 0 saute à lui-même, s'exécutant pour toujours.

À ce stade, vous pensez peut-être:

Bien sûr, monorail, tout cela a du sens, mais votre réponse est simple NOP. Pourquoi son score est-il 6 octets?

Bonne question, merci de demander. On peut penser naïvement que les programmes TIS doivent être comptés de la même façon que les programmes dans plusieurs fichiers: le nombre d'octets dans tous les nœuds, plus un octet pour chaque nœud supplémentaire après le premier. Cependant, la communauté de golf de TIS a décidé que cela serait injuste pour la simple raison qu’elle ignore certaines des informations requises pour recréer des solutions. Les voisins d'un nœud sont très importants et cette méthode de scoring vous donne des informations de position gratuitement. Au lieu de cela, nous avons adopté le format utilisé par l’émulateur TIS le plus courant, le nom déroutant. TIS-100. (Note latérale: Merci de ne pas nommer les émulateurs d'après le système qu'ils émulent. Ce n'est pas intelligent, c'est simplement ennuyeux et oblige tout le monde à clarifier constamment ce dont ils parlent.) C'est très simple: les 12 nœuds d'un TIS-100 Les périphériques sont numérotés, de gauche à droite et de haut en bas, ignorant tous les nœuds de stockage installés par le système émulé. Un nœud numéroté Ncontenant # CODE\n# CODE\n CODEest enregistré comme suit:

@N
# CODE
# CODE
# CODE

Et ainsi, un nœud numéroté 0 contenant NOPest marqué en fonction de sa représentation dans ce format:

@0
NOP

Six octets.

Comme j'inclus souvent dans mes réponses dans des langues visuellement intéressantes, vous pouvez regarder l'émulateur TIS-100 exécuter ce programme sur YouTube . Cependant, compte tenu de la nature de ce défi, je ne sais pas ce que vous attendez de voir ...

C # , 38 37 36 octets

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

Pour la boucle sans condition d'arrêt.

Le retour de main devrait être un int, mais comme il n'atteindra jamais la fin, cela devrait compiler. (Testé dans VS 2015 et 2013, fonctionne également dans Ideone ). Merci Geobits et MichaelS .

Une version plus courte, 35 octets, peut être réalisée, mais des impressions Process is terminated due to StackOverflowExceptionqui, à mon avis, violent le troisième point de ne rien imprimer sur stderr. Crédit à MichaelB

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

Foo, 3 octets

(1)

Le langage de programmation préféré de tous! :RÉ

Hexagone , 1 octet

.

Je ne connais pas grand-chose à propos de ce langage génial créé par @ MartinBüttner, mais d'après ce que j'ai vu, cela devrait se dérouler indéfiniment, car il n'y a pas moyen @d'arrêter le programme. .est tout simplement un no-op.

Perl, 4 octets

do$0

S'exécute à plusieurs reprises.

Gammaplex , 0 octet

Dans Gammaplex, il n'est pas possible d'écrire un programme qui n'est pas une boucle infinie. Donc, je viens d'écrire un programme qui n'utilise pas d'entrée / sortie.

Pyth, 2 octets

# 

Pyth attend des jetons après l'opérateur pour toujours. (C'est un espace.)

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

yes>&-

yessorties "y" pour toujours; >&-ferme STDOUT.

Merci @Dennis et @ThisSuitIsBlackNot pour nous aider à réduire la taille!

Common Lisp, 6 caractères

(loop)

Fission , 1 octet

Il existe exactement 4 solutions à un octet:

R

L

U

D

Ces quatre lettres indiquent qu'un atome commence à cet endroit (dans la direction correspondante). L'un d'eux est requis car sans atome, le programme se termine immédiatement. Comme le code source n’a qu’un caractère, l’atome s’enroulera immédiatement et exécutera à nouveau la même cellule. Cependant, après le début du programme, il UDLRsuffit simplement de dévier un atome entrant dans la direction correspondante, de sorte qu’ils deviennent des no-ops dans ce cas.