Une machine à vérité (c'est à ce type qu'il revient de l'avoir inventé) est un programme très simple conçu pour montrer le flux d'E / S et le contrôle du langage. Voici ce qu'une machine à vérité fait:

• Obtient un numéro (0 ou 1) de STDIN.

• Si ce nombre est 0, imprimez 0 et terminez.

• Si ce nombre est 1, imprimez 1 pour toujours.

Défi

Écrivez une machine à vérité comme décrit ci-dessus dans la langue de votre choix. La machine à vérité doit être un programme complet qui suit ces règles:

• prendre la contribution de STDIN ou une alternative acceptable
  • Si votre langue ne peut pas accepter la saisie de STDIN, elle peut également provenir d’une variable codée en dur ou d’un équivalent approprié dans le programme.
• doit sortir vers STDOUT ou une alternative acceptable
  • Si votre langue est incapable de sortir les caractères 0ou 1, une entrée / sortie octet ou unaire est acceptable.
• quand l'entrée est 1, il doit continuellement imprimer 1s et ne s'arrêter que si le programme est tué ou s'il manque de mémoire

• la sortie ne doit être qu'un 0suivi d'un seul ou d'aucun caractère de nouvelle ligne ou d'un espace, ou un nombre infini de 1s 1suivi de chacun par un ou aucun nouveau caractère ou espace. Aucune autre sortie ne peut être générée, à l'exception d'une sortie constante de l'interprète de votre langue qui ne peut pas être supprimée (message d'accueil, codes de couleur ANSI ou indentation, par exemple). Votre utilisation des nouvelles lignes ou des espaces doit être cohérente: par exemple, si vous choisissez de générer 1une nouvelle ligne après tout, vous 1devez y insérer une nouvelle ligne.

• si et seulement si votre langue ne peut pas se terminer sur une entrée de 0celle-ci, il est acceptable que le code entre dans une boucle infinie dans laquelle rien n'est sorti.

S'agissant d'un catalogue, les langues créées après ce défi sont autorisées à entrer en compétition. 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. En dehors de cela, toutes les règles standard du code-golf doivent être respectées. Les soumissions dans la plupart des langues seront notées en octets selon un codage préexistant approprié (généralement UTF-8).

Catalogue

L'extrait de pile au bas de cet article génère le catalogue à partir des réponses a) sous forme de liste des solutions les plus courtes par langue et b) sous forme de classement global.

Pour vous assurer que votre réponse apparaît, commencez votre réponse par un titre, en utilisant le modèle Markdown suivant:

## Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores en les effaçant. Par exemple:

## Ruby, <s>104</s> <s>101</s> 96 bytes

Si vous souhaitez inclure plusieurs numéros dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou si vous souhaitez répertorier séparément les pénalités d'indicateur d'interprétation), assurez-vous que le score réel est le dernier numéro de l'en-tête:

## Perl, 43 + 2 (-p flag) = 45 bytes

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de code:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

<style>body { text-align: left !important} #answer-list { padding: 10px; width: 290px; float: left; } #language-list { padding: 10px; width: 320px; float: left; } table thead { font-weight: bold; } table td { padding: 5px; }</style><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><script>var QUESTION_ID = 62732; var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe"; var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk"; var OVERRIDE_USER = 12012; var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page; function answersUrl(index) { return "https://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 "https://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.toLowerCase(), 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 > b.lang_raw) return 1; if (a.lang_raw < b.lang_raw) 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); } }</script>

Hexagonie , 6 octets

C'était étonnamment délicat, et je ne suis pas convaincu que ce soit optimal ...

<.@!$?

Après avoir rempli et déplié le code, cela représente la grille hexagonale suivante:

Cela utilise un flux de contrôle similaire à celui de mon récent programme de chat sans erreur , qui suit des anti-diagonales. Pour y parvenir, nous commençons par dévier le pointeur d’instruction (IP) vers la gauche, où le chemin violet s’enroule dans le coin inférieur gauche.

?lit l'entrée sous forme d'entier. !l'imprime en retour. .est juste un no-op. Maintenant le coin de la grille agit comme une branche:

Si l'entrée était 0, l'IP continuera le long du chemin rouge, qui termine simplement le programme avec @.

Si l'entrée était 1, l'IP continuera sur le chemin vert. Encore une fois, .c'est juste un non-op, mais $c'est l'équivalent du trampoline de Befunge: il saute l'instruction suivante. Après l’emballage, l’instruction suivante serait le ?, mais en raison de l’ $exécution, elle continue sur le chemin bleu, en commençant par !imprimer une autre copie du fichier 1. Cette boucle qui ne contient que !..$se répète maintenant indéfiniment.

Une étude du flux de contrôle en hexagone ...

Je crois que la solution ci-dessus est optimale. J'ai écrit un test forcé brutal, qui vérifie tous les programmes Hexagony de 6 octets, qui en contiennent au moins un ?!@(ce qui est nécessaire; j'ai également vérifié :et %au lieu de @terminer avec une erreur de division par zéro, mais cela n'a pas aidé non plus). Le chèque imprime tous les programmes qui a) produisent une 0entrée 0et se terminent et b) produisent au moins deux 1s (et rien d’autre) et ne se terminent pas dans les 60 premiers ticks du programme (200 ticks pour des solutions à 5 octets) . Je doute qu'une solution valable prenne plus de 200 ticks pour imprimer correctement la première 0ou la seconde 1sur une grille aussi petite. Je ne pense donc pas avoir manqué de solutions potentielles.

La recherche n'a donné aucun résultat pour 5 octets, mais 57 résultats pour 6 octets (en utilisant @; il n'est pas nécessaire de terminer par une erreur si nous pouvons résoudre ce problème proprement dans le même nombre d'octets). Sur ces 57, seuls 6 étaient des faux positifs qui n’imprimaient en réalité que deux 1secondes puis entraient dans une boucle infinie sans plus imprimer. Une solution a été répertoriée deux fois car elle contenait deux !commandes. Cela laisse exactement 50 solutions valables.

Il existe une certaine dégénérescence entre les solutions où un ou deux caractères ne sont pas substantiels, par exemple parce qu’ils sont de toute façon sans exception. Les solutions peuvent être regroupées en 23 ensembles de programmes véritablement distincts (dans certains cas, il n’ya qu’une différence de caractère entre deux ensembles, mais cela modifie considérablement le flux de contrôle, je les ai donc comptés séparément). Deux des groupes utilisent même plusieurs indicateurs d'instruction de manière très inattendue. Comme je n’aurais jamais trouvé la plupart de ces façons d’utiliser les branches et les miroirs, elles constituent une étude très intéressante sur les types de flux de contrôle possibles dans Hexagony, et j’ai définitivement appris de nouvelles astuces pour les futurs golfs.

Le flux de contrôle global est presque toujours le même: lisez un nombre, imprimez-le. Si c'est le 0moyen de trouver le @, sinon continuez en boucle !tout en conservant une valeur de bord de 1. Il y a quatre exceptions notables:

• Une solution (celle avec deux !) imprime deux 1s par itération dans la grille, soit environ deux fois plus vite que la majorité des programmes. J'ai marqué celui-ci avec x2ci-dessous.
• Quelques solutions (celles qui contiennent un o) remplacent le 1avec un 111(le code de caractère de o), de sorte qu’elles impriment trois 1 secondes par itération, leur permettant d’imprimer environ trois fois plus vite que la plupart des programmes. Je les ai marqués avec x3ci-dessous.
• Deux solutions ajoutent un a 1la valeur du bord à chaque itération (donc 1-> 11-> 111-> ...). Ceux-ci impriment très vite, mais ils finiront par manquer de mémoire. Je les ai marqués avec OoMci-dessous.
• Deux solutions entrent dans une boucle très serrée qui ne fait que rebondir par-dessus l’ !impression, imprimant tous les tics (au lieu de tous les 5 secondes environ), ce qui les rend légèrement plus rapides (et plus propres). Je les ai marqués avec ><ci-dessous.

Alors voici le zoo entier:

#1                #5                #12                #19
?!/$.@            ?$!>$@            .?!/$@             |!|?$@  # ><
?!/$1@  # OoM     ?$!|$@            =?!/$@
?!/$=@                                                 #20
?!/$\@            #6                #13                $@.?<!
?!/$o@  # x3      ?/!<|@            .?/!$@             $@1?<!  # OoM
?!/$!@  # x2                        =?/!$@             $@=?<!
                  #7                                   $@o?<!  # x3
#2                ?\!<|@            #14
?!>$)@                              \!?__@             #21
?!>$1@            #8                                   _>_!?@
?!>$o@  # x3      ?<!>$@  # ><      #15
?!|$)@                              \_?!$@             #22
?!|$1@            #9                                   <!@.$?
?!|$o@  # x3      ?\$!@$            #16                <!@/$?
                                    \_?!_@             <!@=$?
#3                #10                                  <$@!$?
?!|)$@            ?~#!@)            #17                <.@!$?
?!|1$@            ?~#!@1            $$?\@!             </@!$?
?!|o$@  # x3                                           <=@!$?
                  #11               #18
#4                ?$)\@!            \$?\@!             #23
?_!<@>            ?$1\@!                               <<@]!?
                  ?$o\@!  # x3

Ce qui suit est une courte présentation de quelques groupes plus représentatifs. Les groupes 10 et 23 sont particulièrement intéressants. Il existe de nombreux autres chemins intéressants et parfois compliqués dans les autres groupes, mais je pense que je vous ai assez ennuyé à la fin. Pour ceux qui veulent vraiment apprendre l’hexagone, il convient néanmoins de s’y intéresser, car ils présentent un nombre encore plus grand d’utilisations possibles des miroirs et $.

Groupe 1

Celui-ci n'est pas beaucoup plus élaboré que ma solution d'origine, mais les chemins vont dans des directions différentes. Il permet également le plus grand nombre de variations dans une seule cellule, car le no-op no-op le plus à droite peut être remplacé par 5 commandes différentes, ce qui permet de rendre cette opération valide sans modifier la structure:

Groupe 2

Celui-ci est très intéressant, car il ne se déplace que horizontalement. Après avoir enveloppé à la >, l'IP inverse immédiatement, en prenant la branche dans le coin. Ce n'est pas tout à fait visiblement pas le diagramme, mais dans le cas de la 1nous traversons à nouveau la première ligne, mais à l'envers cette fois. Cela signifie également que nous nous heurtons à ?nouveau, ce qui nous revient maintenant 0(EOF). Ceci est corrigé avec )(incrément) pour continuer à imprimer 1s. Cela a aussi 5 variations, comme cela )pourrait aussi être 1ou o, et >pourrait aussi être |:

Groupe 3

Celui-ci semble presque identique au précédent, mais c'est désordonné. Jusqu'à frapper |puis traverser la rangée du bas ou du haut, c'est la même chose. Mais dans le cas d'une boucle, le $passe maintenant ) sur le miroir. Nous suivons donc le chemin turquoise à droite, maintenant frappé l'incrément, sauter par- dessus l' @avant enrouler autour de la à | nouveau et puis remontons sur le chemin vert en haut.

Groupe 4

Je pensais que celui-ci était particulièrement chouette:

Le _miroir dans le coin supérieur droit est d’abord un no-op, nous imprimons avec !et appuyons sur le <. Le 0chemin frappe maintenant le miroir horizontal et se termine. Le 1chemin prend une trajectoire très intéressante cependant: il dévie vers le bas, enveloppements au !, est redirigé vers l'horizontale et enveloppe puis de nouveau à la ! fois . Il continue ensuite à avancer dans cette forme de losange, en imprimant deux fois par itération (tous les trois tics).

Groupe 8

C'est l'une des deux solutions avec une boucle d'impression très serrée:

Le <agit comme la branche. Après avoir emballé deux fois, 0frappe @. 1d'autre part, saute d'abord le ?, puis l' >envoie à $nouveau, donc saute le @. Ensuite, l’IP s’enroule dans le chemin turquoise, où il rebondit entre le >et <((entourant le bord entre les deux).

Groupe 10

L'un des deux groupes qui utilisent d'autres pointeurs d'instructions, et c'est absolument magnifique. Hexagony en a 6 - chacun part d'un coin différent le long du bord des aiguilles d'une montre, mais un seul d'entre eux est actif à la fois.

Comme d'habitude, on lit avec ?. La ~négation est maintenant unaire: elle transforme le 1en -1. Ensuite, nous avons frappé le #. C'est un moyen de basculer entre les adresses IP: il prend la valeur de front actuelle modulo 6 et bascule sur l'adresse IP correspondante (les adresses IP sont numérotées 0dans le sens des aiguilles d'une montre). Donc, si l’entrée était la suivante 0, l’adresse IP reste simplement la même et se déplace ennuyeusement droit devant elle !@. Mais si l'entrée était 1, alors la valeur actuelle est -1ce qui est 5 (mod 6). Nous passons donc à l’IP qui commence sur la même cellule (le chemin vert). Now #est un no-op et ?définit le bord de la mémoire à 0. )incrémente donc !imprime a 1. Maintenant, nous avons ~encore frappé pour nous assurer que#est toujours un no-op (par opposition à nous passer à IP 1 qui mettrait fin au programme). C'est incroyable de voir à quel point tout concorde dans ce petit programme.

Groupe 22

Il est juste de noter que c’est le groupe dans lequel se trouve ma solution initiale. Il s’agit également du groupe le plus important, car le no-op peut se trouver à deux endroits différents et il existe plusieurs choix pour la commande réelle (no-op effective).

Groupe 23

C'est l'autre groupe qui utilise plusieurs adresses IP. En fait, celui-ci utilise 3 adresses IP différentes. Le coin en haut à droite est un peu en désordre, mais je vais essayer de vous expliquer:

Ainsi, le début que vous avez vu auparavant: <dévie le nord-est, ?lit les entrées. Il ]existe maintenant un autre moyen de changer d’adresse IP: il passe le contrôle à la prochaine adresse IP dans le sens des aiguilles d’une montre. Nous passons donc le contrôle sur le chemin turquoise qui (je sais que c'est difficile à voir) commence dans le coin nord-est en direction du sud-est. Cela se reflète immédiatement <dans le coin sud-est, en direction nord-ouest. Il frappe également le ]donc nous passons à la prochaine adresse IP. C'est le chemin gris qui commence dans le coin est et se dirige vers le sud-ouest. Il imprime l'entrée, puis passe au coin nord-est. <dévie le chemin dans l'horizontale, où il est reflété par l' autre < . Maintenant la main droite<agit comme une branche: si l’entrée était 0, l’IP se déplace vers le nord-est, et encapsule vers le @. Si l'entrée était 1, l'IP se déplace vers le !, enveloppe le le-thand <où il est reflété ... maintenant dans le coin, il retourne vers le !, est dévié par la droite <, reflété par la gauche <et les chemins commencent plus de...

Tout un gâchis, mais un beau gâchis. :)

Diagrammes générés avec l' étonnant HexagonyColorer de Timwi .

Motorola MC14500B Code machine, 2 octets

En hex:

58EC

Explication:

5  OR the register with input from the data bus
8  Write the register to the data bus
E  Skip next instruction if register is zero
C  Jump

Le Motorola MC14500B est un microcontrôleur 1 bit. il possède un registre 1 bit et un bus de données 1 bit. Étant donné que les codes d'opération sont de 4 bits chacun, il n'y en a que 16; la moitié d'entre eux effectuent une opération logique entre le registre et le bit sur le bus de données.

L'instruction de saut définit un drapeau de saut; lorsqu'aucune adresse n'est fournie, il est courant de régler le compteur de programme sur 0. Si le bit d'entrée était à zéro, le processeur ne sautera pas. Si le bit d'entrée était à 1, le processeur revient au début; Puisque nous avons ORune entrée, peu importe le signal d’entrée, le registre sera alors 1 pour toujours.

Comme il est classique, le registre est initialisé à 0.

Une liste des opcodes se trouve sur la fiche technique ou ici .

Arnold C, 296 octets

IT'S SHOWTIME
    HEY CHRISTMAS TREE i    
    YOU SET US UP @NO PROBLEMO
    BECAUSE I'M GOING TO SAY PLEASE i
        STICK AROUND i
            TALK TO THE HAND i
        CHILL
    BULLSHIT
        TALK TO THE HAND i
    YOU HAVE NO RESPECT FOR LOGIC
YOU HAVE BEEN TERMINATED

Pas vraiment compétitif, mais pour le plaisir. Ne supporte pas stdin, remplace par @NO PROBLEMOavec @I LIEDune valeur de zéro. @No Problemoest 1.

Exécuter avec (en supposant que le fichier est truthmachine.arnoldc):

wget http://lhartikk.github.io/ArnoldC.jar
java -jar ArnoldC.jar truthmachine.arnoldc
java truthmachine

Minecraft, 18 octets (version MC 15w45a)

Comme vous pouvez le constater, un levier est dirigé vers le bloc de commandes répétitif, qui contient la commande say 1. Il y a une torche d'inversion de signal en plus de celle-ci, qui dirige l'alimentation dans le bloc de commandes à exécution unique contenant la commande say 0.

Chaque fois que le commutateur est orienté vers la vérité, le bloc répéteur utilise le code say 1pour produire une infinité de 1s. Lorsque le levier est redirigé sur false, il en émet un seul 0.

Notez que cela génère un [@]par défaut. Si vous voulez vraiment juste des 1 et des zéros, cela devient 34 octets, où le code dans les blocs de commande sont tellraw @a [1]et tellraw @a [0]. Ceci utilise le nombre d'octets suggéré par @ Cᴏɴᴏʀ O'Bʀɪᴇɴ pour MC, comme on peut le trouver dans Meta .

Bash + GNU utils, 13

grep 0||yes 1

Bash, 35 ans

read n;for((;n;));{ echo 1;};echo 0

Ruby, 20 ans

print while/1/||gets

Exécuter à partir de la ligne de commande pour éviter les avertissements, comme

ruby -e "print while/1/||gets" <<< 0
ruby -e "print while/1/||gets" <<< 1

Explication:

Moins joué au golf, c’est

while /1/ || gets
  print
end

Lorsqu'une expression rationnelle est utilisée dans une condition, elle est évaluée comme étant falsey sauf si la variable $_est renseignée et correspond au modèle. Lors du premier passage dans la boucle, il $_est vide et nous tombons sur gets, ce qui définit la valeur de $_sur une ligne lue à partir de STDIN. printsans argument imprime $_. Maintenant, nous évaluons à nouveau le conditionnel. Si nous lisons dans 1, nous court-circuitons et imprimons simplement 1 à nouveau, et ainsi de suite. Sinon, nous échouons gets, mais comme il n'y a pas de deuxième ligne d'entrée, getsretourne la valeur nil, la boucle se termine.

Microscript, 3 octets

i{p

Le plus court que je connaisse.

Explication:

i  Takes numeric input and puts it in register 1
{  while register 1 is truthy
  p  Print the contents of register 1

Microscript imprime implicitement le registre 1 à la fin, raison pour laquelle une entrée 0est imprimée une fois.

Code machine de Turing, 32 octets

Utilisation de la syntaxe de la table de règles trouvée ici.

0 0 0 * halt
0 1 1 r 1
1 _ 1 r 1

JavaScript, 28 octets

Les boucles sont souvent plus courtes que les boucles while.

alert(x)renvoie undefined, ce qui est faux, ainsi le bitwise ou l'opérateur |, le jette sur 0. Ainsi, si xest "0", alerte une fois, sinon continuez à boucler. Utilise alertpour STDOUT comme cette réponse .

for(x=prompt();alert(x)|x;);

Python 2, 29 octets

a=input()
while 1:print a;1/a

Cela se termine par une erreur de division activée 0, autorisée par défaut .

Brainfuck, 41 36 31 30 octets

Réduit en imprimant une fois juste après la saisie et avec l'aide d'Ethan et de user46915.

,.+++[->>+<-----<]>>---<-[>.<]

Version précédente: Soustrayez 48 de l’entrée, et si elle n’est pas nulle, ajoutez 1 à la 48 pour imprimer ASCII 1définitivement, sinon imprimez 0.

-[>+<-----]>--->,<[->->+<<]>[>+<]>.<[>.<]

Je l'ai exécuté ici , mais en raison d'une sortie en mémoire tampon, vous ne pouvez voir aucune sortie car le programme ne se termine jamais 1.

Edit: j'avais oublié d'imprimer 0en entrée 0. Correction maintenant. J'aime les >.<visages à la fin.

Piet, 27 18 16 codels

(Codel est un nom sophistiqué pour le pixel utilisé pour éviter la confusion quand une image est étirée pour être visionnée. J'ai compté les codels au lieu d'octets car les scripts de pixels sont sauvegardés en tant qu'images, donc la taille physique peut varier. Je pense qu'un format de fichier idéal qui permettrait d'économiser ce piet aussi efficacement que possible prendrait 11 octets. En pratique, mon petit fichier gif est de 62 octets, avec des données de palette optimales. Dites-moi si je devrais utiliser ceci comme taille de mon entrée au lieu de la quantité de code.)

Image originale:

Agrandie:

En piet, la différence entre deux couleurs est ce qui détermine la commande exécutée. Voir deux fois la même couleur ne signifie donc pas qu’il fait la même action. L'exécution commence dans le code en haut à gauche. Ensuite, il se déplace horizontalement, en effectuant les opérations suivantes:

1. Lire un nombre et le mettre sur la pile
2. Dupliquer le haut de la pile
3. Pop et sortie en haut de la pile
4. Pop le haut de la pile et tournez dans le sens des aiguilles d'une montre ce nombre de fois.

Si la valeur est 1, le curseur descend dans le code de chaux, ce qui pousse 1 sur la pile. Ensuite, l'exécution continue en allant à gauche. Lorsque le curseur passe d'une couleur à un blanc et d'un blanc à une couleur, rien ne se produit. Etant donné que le noir est également considéré comme un mur, le curseur revient au code de la chaux sur la ligne supérieure et répète le tout à partir de l'étape 2.

Si, toutefois, l’entrée était 0, le curseur ne descendra jamais et se retrouvera dans le J bleu à droite (jeu de mots voulu, cela en valait la peine), s’il restera bloqué (parce que le haut, droite, gauche et les côtés inférieurs de ce bloc en forme de J sont à côté des codes noirs ou du bord de l’image). Puisque le curseur est pris au piège, l'exécution se termine.

Valeurs inattendues:
si l'utilisateur écrit un autre numéro, il sera toujours imprimé, puis le curseur pivotera plus ou moins de fois en fonction de la valeur.

• Multiple de 4 ou 0: l'exécution se poursuit horizontalement et se termine.
• Multiple de 3: Comme il est impossible de monter, le curseur tourne immédiatement dans le sens des aiguilles d'une montre et continue horizontalement, puis se termine.
• Multiple de 2 et non un multiple de 4: le curseur pivote et commence à se déplacer vers la gauche. Heureusement, cela ne fait que réaliser un tas d'opérations qui n'affectent pas le déroulement du programme et finissent par vider la pile. Lorsqu'une opération ne peut pas être effectuée car la pile est vide, elle est simplement ignorée. Quand il frappe le coin en haut à gauche, le curseur n'a nulle part où aller, mais à nouveau à droite, ce qui redémarre effectivement le programme.
• Autres valeurs: Le curseur s'abaisse comme s'il le ferait avec 1, ce qui lui fait imprimer 1 pour toujours. Si l’entrée est 5, la sortie sera5111111111111...

Toute valeur non entière terminera le programme. L'exécution continuera normalement, mais toutes les opérations seront ignorées car il n'y a rien dans la pile. D'une certaine manière, le programme ne se bloque jamais - il s'arrête normalement ou tourne en boucle pour toujours.

PietDev version conviviale

PietDev (un Piet IDE en ligne très basique) semble avoir des problèmes avec les codes blancs, j'ai donc créé une nouvelle version qui effectue une rotation manuelle, au lieu de compter sur une rotation automatique des codes blancs appropriée. Et je n'ai même pas eu besoin d'utiliser une nouvelle couleur! Si vous souhaitez tester, veillez à dessiner une bordure noire autour du code, car PietDev ne prend pas en charge les tailles de programme personnalisées.

Versions plus anciennes

La première version n'a pas repoussé 1 sur la pile et a été rebouclée sur une instruction de duplication antérieure. Il y avait aussi des codels décoratifs inutiles.

Ensuite, j'ai eu l'idée d'appuyer sur 1 sur la pile pour supprimer la ligne blanche. C'est marrant comme j'y ai pensé grâce à mes codels décoratifs.

Ensuite, j'ai réalisé que j'avais une duper superflue dont je n'avais plus besoin, et j'ai réduit le nombre de couleurs pour sauvegarder les données de palette dans l'image. Je me suis également débarrassé du code unique décoratif parce que je ne sais pas.

Pyth, 4 3 2

Wp

Il y a un non! espace de fuite (merci isaac :)). Auparavant, l'espace requis pour compiler la boucle while était compilé, mais Pyth a depuis été mis à jour. Normalement, cela disqualifierait son utilisation, mais puisqu'il s'agit d'un catalogue, il devrait être valide.

Explication:

Wp        : implicit Q = eval(input)
W         : while
 p        : print and return the value of Q, to be evaluated as the while condition
          : Functions without enough arguments automatically use Q now
          : do nothing in the body of the while loop

Puce , 6 octets

e*faAs

Chip est un langage 2D qui se comporte un peu comme un circuit intégré. Il prend en entrée, un octet à la fois, et sépare les bits en éléments d’entrée individuels. Output coud les valeurs des éléments de sortie en octets.

Décomposons ceci:

*est un signal source, il enverra une valeur vraie à tous les éléments adjacents. eet fcorrespondent aux cinquième et sixième bits de la sortie. Donc, e*fproduit binaire 00110000, qui est le caractère ASCII "0".

Maintenant, Aest le premier bit d'entrée et ale premier bit de sortie, donc aAcopie ce bit d'entrée à sortie. Ainsi, lorsque combiné avec e*f, une entrée ASCII "0" produit "0" et "1" produit "1". (Il n'y a pas d'interaction entre fet a, car aucun ne produit de signal.)

A sla fin, lorsqu'il est activé par un signal vrai, empêchera l'entrée de passer à l'octet suivant, ce qui signifie que tout fonctionnera à nouveau avec la même entrée.

Étant donné que le premier octet de "0" est zéro, il n'active pas cet élément et le programme imprimera "0", épuisant ainsi son entrée, ce qui lui permet de se terminer. "1", cependant, active cet élément, ce qui signifie que "1" est sorti, mais pas consommé sur l'entrée, permettant ainsi au cycle de se répéter indéfiniment.

Si les valeurs 0x0 et 0x1 sont utilisées pour la sortie plutôt qu'ASCII, nous pouvons éliminer la e*fpartie, ce qui donne seulement 3 octets :

aAs

Si le zéro doit se terminer lui-même, plutôt que de s'attendre à la fermeture de stdin, nous obtenons ce qui suit, qui inverse le premier octet avec ~et transmet le résultat à tqui termine le programme ( 10 octets ):

aA~te*f
 s

( tne produit également aucun signal, il n'y a donc pas d'interaction entre tet e.)

Brainbool , 5 octets

,.[.]

Brainbool est Brainfuck, mais il ne fonctionne que sur les bits, et effectue les entrées / sorties 0et les 1caractères.

LOLCODE, 119 octets

GIMMEH n
n R SUM OF n AN 0
BOTH SAEM n AN 0, O RLY?
YA RLY
 VISIBLE 0
NO WAI
 IM IN UR l
  VISIBLE 1
 IM OUTTA UR l
OIC

Ungolfed:

HAI

BTW, Read n as a string from STDIN and convert to an integer
GIMMEH n
n R SUM OF n AN 0

BTW, Test n for equality with 0
BOTH SAEM n AN 0, O RLY?
YA RLY
    BTW, Write 0 to STDOUT and exit
    VISIBLE 0
NO WAI
    BTW, Loop forever, printing 1
    IM IN YR l
        VISIBLE 1
    IM OUTTA YR l
OIC

KTHXBYE

C, 37 octets

Une autre façon de procéder en C.

main(c){for(gets(&c);putchar(c)&1;);}

cLa valeur par défaut est un intde valeur 1. gets(&c)obtient une chaîne de stdin, ici engloutissant la valeur de c, de façon hackishly puisque cn'est pas un char*. putchar(c)imprime la valeur cà stdout, et retourne c. Comme '0'est 48 et '1'49 en ASCII, nous pouvons utiliser le dernier bit ( &1) pour déterminer lequel il s’agit. Si c'est le cas '0', la boucle se rompt. Sinon, ça va pour toujours.

Compile (avec un avertissement à propos de gets) et fonctionne sous gcc-4.8Linux.

Labyrinthe , 7 octets

 ?+
@!:

Labyrinth est un langage basé sur la pile 2D où le contrôle dépend du signe de l’élément supérieur de la pile, vérifié après chaque instruction. L'exécution commence à se déplacer vers la droite à partir de la première instruction valide de la rangée supérieure, qui est la suivante ?.

Les instructions pertinentes sont:

?      Input integer
+      Add top two elements (Labyrinth's stack has infinite 0s on the bottom)
:      Duplicate top element
!      Output as number
@      Terminate program

Si l'entrée est 0, l'adresse IP lit avec ?, ajoute les deux premiers de la pile ( 0 + 0 = 0), puis duplique :et génère !un 0. Ici, nous rencontrons l'unique jonction du programme et nous devons vérifier le haut de la pile pour déterminer où aller. Puisque le sommet est 0, on avance et on termine avec @.

Par contre, si l’entrée est 1, on fait la même instruction qu’auparavant (mais on émet un 1) avant d’atteindre la jonction au !. Maintenant, le sommet de la pile est positif, nous obligeant à tourner à droite dans le ?. Sur EOF Labyrinth pousse 0, nous faisons donc 0 + 1 = 1à la +duplication :et à la sortie !. Encore une fois, nous avons un 1 en haut de la pile et la boucle continue.

Pour un bonus, voici la solution à 7 octets de @ MartinBüttner, qui fonctionne de la même manière:

?+!@
1!

Notez que, contrairement à la plupart des langues, 1apparaît en fait nla pile et pousse n*10 + 1, ce qui rend l'édification d' un grand nombre facile. Cependant, comme le haut de la pile est vide à ce stade, il n’ya pas de différence en poussant 1.

> <> , 7 octets

i2%:n:,

Ceci utilise le fait que> <> pousse -1 sur EOF, ce qui correspond à 1 mod 2. Il utilise également la division par 0 pour la terminaison (ce qui est apparemment correct puisque le consensus est que la sortie de STDERR est ignorée).

Juste pour référence, quitter proprement sans erreurs est un octet supplémentaire:

i2%:n?!;

APL, 6 octets

→⎕←⍣⍲⎕

Explication:

     ⎕ Read the input, then
 ⎕←    write it out
   ⍣   repeatedly
    ⍲  until NAND of it with itself becomes true.
→      Branch to zero to avoid printing the result again.

Brian & Chuck , 21 octets

,}<-{-?<SOH>_{+?
_>+{?<.p

Ici, <SOH>doit être remplacé par le caractère de contrôle correspondant (0x01).

Explication

L'idée de base est de soustraire le code de caractère de l'entrée (48 ou 49) de la pfin de Chuck, ce qui donnera soit un ?(qui est une commande valide), soit @un non-op.

,lit le caractère saisi dans la première cellule de Chuck (marqué d'un _). Nous voulons décrémenter cette valeur 0dans une boucle, tout en apportant d'autres modifications:

}<se déplace vers le pet le -décrémente. Ensuite , {se déplace à la cellule d'entrée -décrémente aussi. Tant que ce n'est pas encore zéro, ?donne le contrôle à Chuck. Déplace maintenant >la tête de bande de Brian d'une cellule à droite (qui est initialisée à 1) et l' +incrémente. Ensuite, nous réinitialisons la boucle avec {?.

Au moment où la première cellule sur Chuck arrive 0, la <SOH>cellule aura été incrémentée dans le caractère que nous avons lu à partir de STDIN et psera utilisée ?pour la saisie 1ou @pour la saisie 0.

Maintenant ?ne change plus de contrôle. Le 0ou 1après c'est un no-op, tout comme le null-byte (représenté par _). {revient à la première cellule de Chuck et +s'incrémente pour s'assurer qu'elle est positive, de sorte que les ?mains contrôlent Chuck.

Cette fois, >+la cellule est incrémentée après la fin de la bande initiale de Brian. Cette cellule est une poubelle, mais nous ne l'utilisons jamais. Maintenant {ne numérise pas tout le chemin à l'avant de la bande de Brian, mais seulement à la _. C'est ?donc un non-fonctionnement car la cellule actuelle est à zéro. Puis <.déplace un vers la gauche (la copie du caractère saisi) et l’imprime.

Enfin, nous rencontrons le ?ou @. Si l'entrée était 0et que cette cellule est, @c'est un no-op et le programme se termine. Mais si l’entrée était 1et que cette cellule était, ?nous passions à Brian {+?qui réinitialiserait la boucle sur Chuck, et maintenant nous imprimons à 1jamais (jusqu’à ce que le nombre entier dans la cellule à la fin de la bande de Brian ne tienne dans la mémoire) plus, je suppose ...).

Prime

Sp3000 et moi jouons au golf depuis plusieurs jours. Nous avons commencé à environ 40 octets et sommes arrivés à deux solutions complètement différentes, mais liées à 26 octets. Ce n'est que lorsque j'ai commencé à rédiger l'explication pour la mienne que la solution à 21 octets ci-dessus m'est apparue. Un grand merci à Sp pour avoir échangé des idées et appris les uns des autres certaines astuces de golf dans B & C. :)

Voici sa solution à 26 octets:

>,----{?{>1?0
#I<?_}<.<<<?

Et voici le mien:

,{>-<-?_0+?_1{<?
_®{?_{>.?

Où ®est un octet de valeur 174 (par exemple, enregistrez simplement le fichier en tant que ISO 8859-1).

À la mine principale fonctionne de la même manière que la solution à 21 octets, en ce sens que cela ®devient }une entrée 1et ~(sans opération) une entrée 0, mais l’exécution est beaucoup moins élégante.

Sa solution est tout à fait intéressante en ce sens que le code source est uniquement ASCII et qu’il ne nécessite pas de boucle pour traiter l’entrée. Au lieu de cela, se ----transforme 1en -et 0en ,(une non-opération pour Chuck). Cela -transformera ensuite le premier ?contenu sur la bande de Brian en un >flux de contrôle différent pour le cas 1.

Balise cyclique binaire , 3 bits ou <1 octet

Bitwise Cyclic Tag est l’un des langages les plus simples de Turing-complete. Cela fonctionne avec deux chaînes de bits, le programme et les données . Les bits du programme sont lus cycliquement et interprétés comme suit:

• 0: Supprimer le premier bit de données (et le sortir, dans les implémentations qui ont une sortie).
• 1x: Si le premier bit de données est 1, ajoutez x(représentant un 0ou ou 1) à la fin des données. (Si le premier bit de données est 0, ne faites rien.)

Le programme s'exécute jusqu'à ce que la chaîne de données soit vide.

Machine à vérité

110

Lorsque la chaîne de données est définie sur 0:

• 11n’ajoute rien car le premier bit de données n’est pas 1.
• 0supprime / affiche 0.
• La chaîne de données est maintenant vide et le programme s’arrête.

Lorsque la chaîne de données est définie sur 1:

• 11ajoute a 1.
• 0supprime / affiche 1.
• La chaîne de données est revenue à un seul fichier 1et le programme est revenu à son point de départ.

GNU sed, 10

:;/1/{p;b}

Explication

• : définir une étiquette sans nom
• /1/Si l'entrée correspond à l'expression régulière 1, alors
• p imprimer l'espace motif (c.-à-d. 1)
• b et revenir à l'étiquette sans nom (pour toujours)
• Si l'entrée n'était pas 1 (c'est-à-dire 0), l'espace du motif est imprimé sans modification et le programme se termine.

Sérieusement , 4 3 octets

_{4 barré est toujours 4 :(}

,W■

,lit une valeur de STDIN. Wdémarre une boucle qui s'exécute alors que la valeur au sommet de la pile est vérité, avec le corps ■. ■imprime l’élément de pile supérieur sans éclater. La boucle est implicitement fermée à EOF.

A l'entrée de 0, la boucle ne s'exécute jamais (car 0is falsey), et le programme se termine à EOF, sautant et imprimant automatiquement toutes les valeurs de la pile. En entrée de la 1(ou toute valeur qui ne soit pas 0, ""ou []), la boucle fonctionne en continu.

En réalité , l'interlignage ,n'est pas nécessaire (grâce à la saisie implicite), ce qui ramène le score à 2 octets.

Jeudi, 34 octets

1::=12
2::=~1
0::=~0
@::=:::
::=
@

Explication:

1::=12 Les instances de la sous-chaîne "1" peuvent devenir "12"

2::=~1 Les instances de la sous-chaîne "2" peuvent être supprimées, en imprimant "1"

0::=~0 Les instances de la sous-chaîne "0" peuvent être supprimées, en affichant "0"

@::=::: Les instances de la sous-chaîne "@" peuvent être remplacées par des chaînes de l'entrée

::= Fin de la liste des règles de substitution

@ La chaîne initiale est "@"

Arnold C, 134 octets

IT'S SHOWTIME
HEY CHRISTMAS TREE i
YOU SET US UP 0         //or 1
STICK AROUND i
TALK TO THE HAND 1
CHILL
TALK TO THE HAND 0
YOU HAVE BEEN TERMINATED

Bien que ce ne soit pas aussi divertissant que l’autre réponse d’ ArnoldC , il joue au golf . Par exemple, l'indentation n'est pas nécessaire, de même que les macros @NO PROBLEMOet @I LIED.

Testé avec cette version du langage , qui ne peut pas prendre en entrée.

Cubix , 5 à 6 octets

Cubix est le nouveau langage bidimensionnel @ETHproductions dans lequel les commandes sont encapsulées autour des faces d’un cube. Interprète en ligne Merci à @ETHproductions pour les économies réalisées.

!I\@O

Cela finit par s'étendre au cube

  !
I \ @ O
  .

Cela commence par la Icommande. Entrez un entier sur la pile.
\, redirige le pointeur d’instruction vers le bas sur le no op.
O, affiche la valeur numérique top of stack.
!, ignore la commande suivante ( @) si top of stack true. Cela fera sauter la \redirection si 1
\, redirige le pointeur d'instruction vers le @programme d'exit.

Cela tire parti du fait que la pile n’éclate pas la pile O ? !.

Foo , 6 octets

&1($i)

Le deuxième caractère est codé en dur car Foo n’a pas d’entrée STDIN. Ne sommes-nous pas d'accord pour dire que Foo est génial maintenant? :)

Explication

&1          Set current cell to 1
  (  )      Do-while loop (or, at least according to the interpreter)
   $i       Print current cell as int

Perl, 18 + 1 = 19 13 + 1 = 14 octets

print while$_

Courez comme ça:

echo -n NUM | perl -p truth.pl

Merci à ThisSuitIsBlackNot (qui est bien meilleur que moi au golf Perl) pour avoir joué au golf cinq octets.

> <> , 6 octets

::n?!;

Pousse l'entrée sur la pile pour commencer

:        copy top element on stack
 :       copy top element on stack again
  n      pop and outputs top element
   ?     condition trampoline - pops top element, if it is zero skips next instruction
    !    trampoline skips next instruction
     ;   finish execution