La boucle infinie la plus courte ne produit aucune sortie

121

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>

Kritixi Lithos
la source
41
Je dois commencer à poster des programmes avec un nombre d'octets négatif pour battre tous ces fichiers vides!
CJ Dennis
3
Ce défi est intéressant car il fait ressortir beaucoup de langues à 0 octet (dont certaines ne sont PAS des esolangs). FWIW, la plupart des langages déclaratifs ont une boucle infinie implicite car les syntagmes déclaratifs n’ont pas de boucle dans leur syntaxe (ils supposent qu’ils s’exécutent dans une boucle infinie). Les schémas à contacts sont peut-être parmi les plus anciennes de ces langues. Ensuite, vous avez le langage d'instruction (IL), une sorte d'assemblage pour les automates programmables qui supposent également une boucle infinie. ILs, comme l'assemblage sont différents entre les fabricants
slebetman
Les programmes qui lisent et exécutent leur propre code source sont-ils autorisés ou les entrées / sorties de fichiers enfreignent-elles la règle "ne doit prendre aucune entrée"?
ThisSuitIsBlackNot
1
@ThisSuitIsBlackNot Oui, l'entrée de fichier est autorisée.
Kritixi Lithos
Pouvez-vous imprimer ""une chaîne vide?
OldBunny2800

Réponses:

216

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

Daniero
la source
10
Aw, j'allais poster ça. : /
Deusovi
5
@daniero Il peut avoir une certaine relation avec cette échappatoire norme ... . Personnellement, je ne suis pas d'accord avec l'échappatoire standard.
Justin
17
@Justin Cette échappatoire ne s'applique qu'à certains types de défis.
Dennis
1
Vous pouvez utiliser <pre>&nbsp;</pre>pour un bloc de code vide.
Immibis
La première chose que je cherchais
Dylan Madisetti
150

L00P , 0 octet



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

Dennis
la source
15
LOL. +1 pour le choix de la langue.
ETHproductions
76
... un de ces jours, cette langue vous
enchaînera
3
+1 pour la référence musicale et félicitations pour un autre badge en or!
Luis Mendo
La meilleure référence que j'ai vue
Christopher
138

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

James King
la source
13
Cela ne devrait-il pas fonctionner sur une machine dotée d'un processeur de la famille 6502/6510, et pas seulement d'un C64? En outre, ce que vous avez écrit est un code machine. L'assemblée seraitBNE -2
Level River St
55
+1 pour créer un programme réellement petit au lieu d'essayer de trouver le langage le plus obscur qui contient le moins de caractères possible pour représenter la structure.
Knetic
1
@ user45891 EB FE est x86. 6502/6510 n'a pas d'instruction de saut court inconditionnel.
Random832
2
Steveverrill, touché, c'est du code machine, en effet. Et oui, je pensais que davantage de gens reconnaîtraient le Commodore 64 que la famille 65xx en général :) Le VIC-20 utilisait le 6502 et aurait pu le faire fonctionner. Donc, techniquement, mon lecteur de disquette 1541 ... Je me souviens vaguement de pouvoir reprogrammer le contrôleur à ce sujet. Ah, mon C64 me manque toujours :)
James King
7
À l’époque, un «truc» particulièrement vicieux (à l’imho du vandalisme) que les clients joueraient avec des propriétaires de magasins d’ordinateurs sans méfiance consistait à placer deux octets semblables à celui-ci, mais pour le X86, au début du chargeur de démarrage, sous DOS ' debug. Cela aurait pour effet de bricoler la machine, et la plupart des employés de magasin n’avaient pas l’impression suffisante pour savoir qu’il ne s’agissait pas simplement d’un disque mort.
Dewi Morgan
105

Brainfuck, 3 octets

+[]

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

mınxomaτ
la source
62
C'est drôle quand BF bat la plupart des autres réponses.
Rohcana
Je devais y penser quand j'ai vu la question sur la page de démarrage de SE.
s3lph
1
Ma première pensée était BF! : D Il a fini plus court que je pensais.
André Christoffer Andersen
1
Alternative, toujours les mêmes octets:-[]
Unihedron
1
Je parie qu'il y a un interprète quelque part où ]cela fonctionnerait
12Me21
102

/// , 3 octets

///

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

Dennis
la source
71
Honnêtement, je suis étonné que le lien fonctionne réellement, vu comment il se termine par ///;)
ETHproductions
@ETHproductions C'est plutôt surprenant, mais si on y pense un peu plus, c'est logique; c'est juste l'URLesolangs.org wiki _ _ _ _
HyperNeutrino
12
@ AlexL. Pas entièrement. Le serveur Web voit une requête GET à/wiki//// . Bien que cela soit censé être un chemin, le serveur peut utiliser ces informations à sa guise.
Dennis
73

Java , 53 octets

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

Yay l'exigence complète du programme!

Géobits
la source
78
Dieu est que verbeux ...
mınxomaτ
4
@minxomat Oui, 45 octets pour un vide main:(
Geobits
3
@minxomat doit aimer ça OOP
Luke
55
Ce n'est pas OO. Mettre du code dans une classe ne le rend pas OO, pas plus que mettre une pierre au micro-ondes en fait un aliment.
imallett
56

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.

coredump
la source
3
Vérifiez si aest vrai en vérifiant si aest vrai en vérifiant si aest vrai en vérifiant ... yay récursivité!
Kirbyfan64sos
50

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
Subvention
la source
1
Il compile, mais si run le système d’exécution détecte la boucle et lève l’ <<loop>>exception - du moins avec ghc. Peut-être qu'un autre compilateur se comporte différemment.
nimi
4
Le faire runhaskell Loop.hsheureusement exécuté pendant plusieurs minutes sur ma machine. Donc, au moins, c'est un interprète qui peut le faire tourner. Je pense que l' <<loop>>exception d'exécution qui ghcjette est purement un détail d'implémentation du moteur d'exécution et ne fait pas partie du langage Haskell tel que spécifié dans l'un des rapports Haskell.
GrantS
C'est un cas de bord. runhaskellaccepte heureusement le code mais il ne boucle pas. Ça ne fait rien Cependant, le défi ne nécessite que de créer la boucle, pas pour l'exécuter, donc je suppose que ça va. Avoir un +1.
nimi
@GrantS: le langage Haskell n'a pas la notion de «boucle»; des définitions comme main = mainsont sémantiquement dans le même seau que undefinedou error "<<loop>>": les valeurs inférieures.
cessé de tourner dans
1
Je pense que la boucle de travail haskell la plus courte serait:main=main>>main
lovasoa
43

Python, 9 octets

Fonctionne en 2 et 3.

while 1:0

Raccourci par @FryAmTheEggman

Ruth Franklin
la source
remarque, cela produit une sortie lorsqu'il est exécuté dans l'interpréteur Python
Chris_Rands
2
@Chris_Rands Seulement dans le REPL.
HyperNeutrino
40

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         [email protected]. ..

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.

casey
la source
9
.comsous DOS serait beaucoup plus court :)
JimmyB
1
Vous n’obtiendrez que des "milliers" d’octets si vous laissez gcc inclure les fichiers de démarrage. yasm && ldrend les exécutables seulement environ 1k.
Peter Cordes
37

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
kirbyfan64sos
la source
12
Comment osez-vous faire un programme intercalaire sanscomefrom
flawr
1
@flawr Fixe. ;)
kirbyfan64sos
4
Np, je pense que nous avons besoin de plus Intercal à des concours de golf ici =)
flawr
16
Est-ce que vous dites PLEASE?
Daniel M.
34

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
ThisSuitIsBlackNot
la source
1
codegolf.stackexchange.com/a/59553/30206 suggère le code sur 4 octets do$0, qui ne fonctionne pas en tant que ligne perl -eunique.
Peter Cordes
@PeterCordes Neat, même si je pense que cela enfreint la règle "ne prendre aucune entrée". do EXPRlit à partir d'un fichier.
ThisSuitIsBlackNot
32

> <> , 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
Fongoïde
la source
11
Essayez ` `le bloc de code.
TheNumberOne
2
Pourquoi ne pas simplement utiliser >?
mbomb007
4
S'il s'agissait de Chem.SE, je recommanderais également de mettre le code dans MathJax.
hBy2Py
Sommes-nous sûrs qu'un programme vide ne serait pas une boucle infinie?
Aaron
1
Obtenez une erreur d'exécution en essayant d'exécuter le programme vide: Traceback (l'appel le plus récent en dernier): fichier "fish.py", ligne 493, dans <module> instr = interpreter.move () Fichier "fish.py", ligne 149, in move if self._position [1]> max (self._codebox.keys ()): ValueError: max () arg est une séquence vide
Fongoid
31

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.

Zach Gates
la source
3
Je pense que vous avez trouvé la langue de golf ultime, du moins pour les petites tâches ... Même Pyth ne peut pas être aussi bref. +1
ETHproductions
Soyez averti que cela s’affiche comme 5 octets sur le tableau de bord.
Addison Crump
C est Jump, mais où sauter?
Kishan Kumar
3
Wow, vous aimez vraiment cette langue, hein? : P
MD XF
Cela fonctionnera dans n’importe quel langage machine où 0 est un NOP, le pointeur d’instruction tourne autour et la mémoire du programme ne contient aucune donnée supplémentaire.
12
30

LOLCODE , 24 octets

IM IN YR X
IM OUTTA YR X
Daniero
la source
3
Dans de nombreux interprètes LOLCODE, comme celui sur repl.it, HAIet ne KTHXBYEsont pas nécessaires.
Alex A.
1
@Alexa. oh, je ne le savais pas. Merci.
daniero
29

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.

marque
la source
4
Sauf si vous pouvez me donner un compilateur qui le fait par défaut, vous devrez ajouter 3 octets pour l' -O2option.
LegionMammal978
19
@ LegionMammal978, selon les règles du défi, un manque de mémoire est acceptable. Cela fait de l' -O2optimisation un "bien-à-avoir" plutôt qu'une exigence.
Mark
1
Si les options du compilateur sont autorisées (et ne comptent pas pour le nombre de solutions), pourquoi ne pas modifier le code l(){l();}et le compiler avec les options-Dl=main -O2
wendelbsilva
1
À titre de comparaison, la plus courte mise en œuvre de la boucle appropriée non récurrent est 16B: main(){for(;;);}.
Peter Cordes
3
@wendelbsilva, vous pouvez encore mieux le changer en changeant le code en X (un octet) et en compilant avec -DX = main () {main ();}
LeFauve
26

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.

Le numéro un
la source
25

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
Daniero
la source
1
Votre vimscript est un peu longwh1|endw
FDinoff
Pouvez-vous expliquer comment cela fonctionne à quelqu'un qui n'est pas familier avec Vim?
iFreilicht
8
@iFreilicht qqcommence à enregistrer dans la qmémoire tampon. @qrejoue ce qui est dans le qtampon (à ce stade, rien). qarrête l'enregistrement, puis @qrejoue ce qui se trouve dans la qmémoire tampon, qui correspond à ce stade aux frappes au clavier @q. Donc, les @qreplays, les @qreplays @q... aussi, écrire ceci qme fait mal au cerveau.
Wayne Werner
25

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:

//+`
Martin Ender
la source
1
Wow, je viens de répondre presque exactement la même chose en même temps .
Kirbyfan64sos
1
@ kirbyfan64sos Ils se ressemblent beaucoup, mais ils fonctionnent assez différemment. :)
Martin Ender
Bon travail. J'allais essayer de faire le programme Retina le plus court en mode Remplacer. Je suis curieux, peut +`correspondre à une entrée vide à plusieurs reprises?
mbomb007
@ mbomb007 Je pense que cela se terminerait 2après quelques itérations.
Martin Ender
24

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
mbomb007
la source
13
Pourquoi le numéro de ligne 10? Pourquoi pas 9?
récursive
25
ou 8 pour 8 octets? :)
MickyT
3
Cela ne va pas gagner et c'est plus drôle de cette façon.
CJ Dennis
3
Cela pourrait être réduit à: 1 RUN
TOOGAM
2
@davidjwest Le plus court que je puisse faire dans Sinclair BASIC est: 1 GOTO SIGNUM PI- étant donné que les entrées constantes sont stockées deux fois en mémoire, ainsi, 1 signifie 4 octets, mais SIGNUM et PI n'utilisent qu'un octet chacun. Ah, les anciennes astuces de codage que nous utilisions auparavant: D Je ne sais pas combien de numéros de lignes de mémoire occupent, le cas échéant, alors je peux dire que c’est plus de 3 octets (stockage de numéro de ligne).
Dewi Morgan
23

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

A single node with NOP written in it

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

métro monorail
la source
Wow-ee. C'était génial.
Adrian Zhang
J'ai toujours pris JROreprésentais J ump à R élatif O ffset.
MutantOctopus
@BHustus, je pense que vous avez raison, mais j'avais déjà écrit ceci avant de connaître un autre langage d'assemblage et je ne connaissais pas le jargon.
undergroundmonorail
Je voudrais pouvoir +10 cette réponse. J'aime TIS-100
Shirkam
J'ai moi-même écrit un émulateur TIS afin que vous puissiez maintenant l' essayer en ligne . Ne vous attendez pas à autre chose qu'un délai d'attente, cependant.
Phlarx
22

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();}
Sven écrit le code
la source
1
Pouvez-vous sauver un en utilisant ;au lieu de {}? Je testerais, mais les services en ligne n'aiment pas beaucoup les boucles infinies.
Geobits
@ Geobits Ah, oui. Comment des choses si simples s'écoulent.
Sven écrit le code
1
Cela peut dépendre du compilateur, mais j’ai sauvé un autre personnage en le déclarant comme int principal et il s’exécutait sans instruction de retour. J'utilise Microsoft Visual C # 2013 Community Version 12.0.31101.00 Mise à jour 4. "class A {statique int Main () {pour (;;);}}"
MichaelS
@MichaelS Merci! Travaillé en 2015 VS pour moi.
Sven écrit le code
1
En vs 15, cela pourrait être plus court (à peine). 35class B{static int Main()=>Main();}
Michael B
21

Foo, 3 octets

(1)

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

kirbyfan64sos
la source
20

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.

ETHproductions
la source
3
Pourquoi ne pas le tester
,:
7
Je peux confirmer que c'est correct. :)
Martin Ender
@KritixiLithos Parce que je ne pouvais pas trouver d'interprète en ligne et que je ne préférais pas télécharger l'interprète pour chaque langue que je voulais tester. ;)
ETHproductions
16
@ETHproductions Vous n'avez pas? Huh.
Martin Ender
1
TIO montre qu'un programme vide fonctionne .
Weijun Zhou
20

Perl, 4 octets

do$0

S'exécute à plusieurs reprises.

Lynn
la source
1
Très cool. Au début, je pensais que cela contrevenait à la règle "ne prendre aucune entrée", car la do EXPRlecture d'un fichier serait techniquement entrée, mais l'OP a précisé que les E / S de fichier sont acceptables. La chose vraiment cool est que contrairement à l'équivalent dans Bash, disons, cela ne crée pas de nouveau processus, il continuera donc indéfiniment sans atteindre aucune limite de mémoire ou de processus.
ThisSuitIsBlackNot
18

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.

jimmy23013
la source
Eh bien, les règles stipulent qu’il faut une boucle infinie pour se qualifier.
arodebaugh
@arodebaugh Il y a. En d'autres termes, chaque programme Gammaplex comporte une boucle infinie.
jimmy23013
16

Pyth, 2 octets

# 

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

Bleu
la source
16

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!

Ben
la source
4
Avec bash, vous pouvez simplement $0exécuter un script shell et l'exécuter, il s'invoquera pour toujours.
TessellatingHeckler
1
Créatif, mais ennuyeux vieux while :;do :;donen’est que 17 octets.
ThisSuitIsBlackNot
3
ping>&- 0fonctionne sur Linux, où 0est mappé sur localhost.
Dennis
1
yes! (J'ai pensé utiliser yesmais je n'ai pas eu l' yes>/dev/null
idée de supprimer
3
Je n'étais pas au courant de ça. Si cela fonctionne avec BSD, oui, bien, mais je ne pense pas que l’écriture dans un fichier ne produise aucune sortie .
Dennis
15

Common Lisp, 6 caractères

(loop)
coredump
la source
44
Y a-t-il quelque chose comme Rare Lisp ?
flawr
10
@flawr Je suppose que c'était juste un commentaire humoristique, mais Common Lisp est le résultat d'un processus de normalisation qui a unifié un tas de langages pour la plupart, mais pas tout à fait compatibles, de la famille Lisp. Les langues de la famille Lisp qui ne sont pas communes à Lisp incluent Scheme, Racket, Emacs Lisp et Clojure.
Joshua Taylor
De plus (un peu plus longtemps, mais si nous ne devions pas compter parens, ce serait seulement deux octets): (do()(())).
Joshua Taylor
@JoshuaTaylor, j'ai aussi réfléchi à l'idée de faire passer dole lecteur en boucle infinie, mais je ne vois pas comment le faire sous peu. Il semble que rien ne bat (loop).
Coredump
@JoshuaTaylor si vous ne comptiez pas parens lisp serait la langue la plus golfeuse de tous
Cyoce
13

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.

Martin Ender
la source