一真机（学分转到这家伙能想出它）是一个非常简单的程序，旨在展示一种语言的I / O和控制流。这是真机的作用：

• 从STDIN获取一个数字（0或1）。

• 如果该数字为0，则输出0并终止。

• 如果该数字为1，则永远打印1。

挑战

用您选择的语言编写如上所述的真机。真机必须是遵循以下规则的完整程序：

• 接受STDIN或可接受的替代方法的输入
  • 如果您的语言不能接受来自STDIN的输入，则可能来自程序中的硬编码变量或适当的等效输入
• 必须输出到STDOUT或可接受的替代方案
  • 如果您的语言无法输出字符0或1，则可以接受字节或一元I / O。
• 当输入为时1，它必须连续打印1s，并且仅在程序被终止或内存不足时停止

• 输出只能是0后跟一个或没有换行或空格，或者是infinite 1，每个1后跟一个或没有换行或空格。除了无法避免的语言解释器的恒定输出（例如问候语，ANSI颜色代码或缩进​​）以外，无法生成其他任何输出。您对换行符或空格的使用必须保持一致：例如，如果您选择在1换行符后输出，则所有换行符或空格后都1必须有换行符。

• 当且仅当您的语言可能无法在其输入上终止时0，代码才可以进入无限循环而没有任何输出的情况是可接受的。

由于这是一个目录，因此可以竞争之后创建的语言。请注意，必须有一个解释器，以便可以测试提交。允许（甚至鼓励）自己为以前未实现的语言编写此解释器。除此之外，必须遵守所有代码高尔夫球的标准规则。大多数语言的提交都将以适当的预先存在的编码（通常为UTF-8）以字节计分。

目录

这篇文章底部的Stack Snippet从答案a）生成目录，答案是每种语言的最短解决方案列表，b）则是总体排行榜。

为确保您的答案显示出来，请使用以下Markdown模板以标题开头。

## Language Name, N bytes

N您提交的文件大小在哪里。如果您提高了分数，则可以通过打败旧分数来保持标题。例如：

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

如果要在标头中包含多个数字（例如，因为您的分数是两个文件的总和，或者您想单独列出解释器标志罚分），请确保实际分数是标头中的最后一个数字：

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

您还可以将语言名称设置为链接，然后该链接将显示在代码段中：

## [><>](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>

六边形，6字节

这出奇的棘手，而且我不认为这是最佳的...

<.@!$?

填充并展开代码后，这表示以下十六进制网格：

这使用了类似的控制流程，例如我最近使用的无错误cat程序，它沿着反对角线移动。为此，我们首先将指令指针（IP）偏向左侧，紫色的路径环绕到左下角。

?读取输入为整数。!打印回来。.只是一个禁忌。现在，网格的角充当分支：

如果输入的是0IP，则IP将沿红色路径继续，该路径仅以终止程序@。

如果输入为1，则IP将在绿色路径上继续。同样，.这只是一个$禁忌操作，但等同于Befunge的蹦床：它将跳过下一条指令。换行后，下一条指令将为?，但由于$执行实际上在蓝色路径上继续，因此从!打印的另一副本开始1。!..$现在仅无限重复此仅包含的循环。

六角形控制流的研究...

我相信上述解决方案是最佳的。我写了一个野蛮的冲头，检查所有6个字节Hexagony方案，其中包含每一个的至少一个?!@（这是必要的;我还检查:和%到位的@一个师零错误终止，但那也没有帮助）。支票打印所有程序，其中a）产生0on输入0并终止，b）产生至少12s（无其他值），并且不终止于程序的前60个滴答声（5字节解决方案为200个滴答声） 。我怀疑任何有效的解决方案都需要200多个滴答声才能在如此小的网格上正确打印第一个0或第二个1，所以我认为我没有错过任何潜在的解决方案。

搜索没有得到5个字节的任何结果，但是得到了6个字节的57个结果（使用@；如果我们可以在相同数量的字节中干净地解决这个问题，则无需以错误结尾）。在这57个中，只有6个为假阳性，实际上只打印了2 1s，然后进入了无限循环而不再打印。一种解决方案被列出两次，因为它包含两个!命令。剩下的就是50个有效的解决方案。

解决方案之间存在一定程度的简并性，其中一个或两个字符并不重要，例如，因为它们实际上实际上是无操作的。解决方案可以分为23套真正不同的程序（在某些情况下，两组之间只有一个字符差异，但是它会大大改变控制流程，因此我将它们分开计算）。其中两个组甚至以非常意外的方式使用多个指令指针。由于我永远不会想出使用支路和镜面的大多数方法，因此它们对Hexagony中可能存在的控制流类型进行了非常有趣的研究，并且我无疑为以后的高尔夫学习了一些新技巧。

在整体控制流程几乎都是一样的：看一个数字，打印。如果0找到通向的方法@，则在保持!边值的同时继续循环浏览1。有四个值得注意的例外：

• 一种解决方案（具有两个解决方案!）1每次通过网格打印两次，因此打印速度约为大多数程序的两倍。我已经在x2下面标记了这个。
• 一些解决方案（那些包含o）替换1用111（字符代码o），所以它们打印3个 1每人S迭代，使他们以最快的速度打印约三倍，因为大多数的节目。我在x3下面用这些标记。
• 在每次迭代中，有两个解决方案将 a 附加1到边缘值上（因此1-> 11-> 111-> ...）。这些打印速度非常快，但最终它们将耗尽内存。我在OoM下面用这些标记。
• 两种解决方案进入一个非常紧密的循环，该循环仅!在上来回跳动，每隔一个刻度（而不是每5个左右）打印一次，这使它们略快（更整洁）。我在><下面用这些标记。

所以这是整个动物园：

#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

以下是少数几个具有代表性的小组的简短演练。特别是第10组和第23组值得一试。在其他小组中，还有许多其他有趣且有时令人费解的路径，但是到此为止，我想我已经很无聊了。对于真正想学习六角形的人来说，这些绝对值得研究，因为它们展示了更多可能的镜子和用途$。

第一组

这个解决方案比我最初的解决方案要复杂得多，但是路径却朝着不同的方向发展。它还可以在单​​个单元格中实现最大数量的变体，因为最右边的无操作可以用5个不同的命令代替，这些命令在不更改结构的情况下仍然有效：

2组

这个很有趣，因为它只能水平移动。包装到后>，IP立即反转，将分支移到角落。显然，这并不是完全没有图表，但是在1我们再次遍历第一行的情况下，但是这次是向后的。这也意味着我们?再次遇到，现在返回0（EOF）。这是固定的)（递增）以保持打印1。这也有5个变体，)也可以是1或o，>也可以是|：

第三组

这个看起来和上一个几乎一样，但是很混乱。直到击中|然后遍历底行或顶行都是一样的。但是，在一个循环的情况下，$现在将跳过的) 上反射镜。所以我们按照绿松石路径正确，打到现在的增量，跳过@之前，我们绕到| 再次和再回到绿色通道顶部。

4组

我认为这个特别好看：

_右上角的镜子最初是禁止操作的，因此我们使用打印!并点击<。0现在，路径撞击水平镜并终止。不过，该1路径采用了一个非常有趣的轨迹：它向下偏转，环绕到!，重新定向到水平，然后! 再次环绕到。然后，它继续以菱形形状移动，每次迭代打印两次（每三个刻度）。

8组

这是两个打印循环非常紧密的解决方案之一：

将<充当分支。包装两次后，0命中@。1另一方面，首先跳过?，然后再次>将其发送到$，因此跳过@。然后，IP 绕入青绿色的路径，在该路径之间，它在>和之间来回反弹<（环绕在它们之间的边缘处）。

第10组

使用其他指令指针的两组之一，它绝对漂亮。六角形有6个-每个都从顺时针边缘的不同角开始，但是一次只有一个处于活动状态。

像往常一样，我们用阅读?。现在~是一元的否定：它把1成-1。接下来，我们点击#。这是在IP之间进行切换的一种方法：它将当前边沿值取模6，然后切换到相应的IP（IP 0沿顺时针方向编号）。因此，如果输入的是0IP，则IP仍然保持不变，并且无聊地直接进入!@。但是，如果输入的是1，那么当前值是-1是5 (mod 6)。因此，我们切换到在同一单元（绿色路径）上开始的IP。现在#是无操作，?并将内存边缘设置为0。)递增，因此!输出1。现在我们~再次点击以确保#仍然是空操作（与将我们切换到IP 1会终止程序相反）。令人难以置信的是，在这个小程序中，各方面的融合程度如何。

22组

请注意，这是我最初的解决方案所在的组。它也恰好是最大的组，因为无操作可能位于两个不同的位置，并且实际（有效的无操作）命令有多种选择。

23组

这是另一个使用多个IP的组。实际上，这个使用3个不同的IP。右上角有些混乱，但我将尝试向您介绍：

因此，您之前看到的开始：<偏向东北，?读取输入。现在]是在IP之间进行切换的另一种方法：它将控制权按顺时针顺序移交给下一个IP。因此，我们将控制切换到绿松石路径，该路径（从我知道很难看到）始于东北角，朝东南方向延伸。它立即被反射，<从而环绕到东南角，向西北延伸。它也命中了，]所以我们切换到下一个 IP。这是一条从东角开始向西南行驶的灰色小路。它打印输入，然后包装到东北角。<将路径偏转到水平方向，并在另一 方向反射<。现在是右手<充当分支：如果输入为0，则IP向东北移动，并包装到@。如果输入为1，则IP移至!，然后缠绕到<左上角，然后反射到该处...现在在角落，它绕回到上!，向右偏斜<，由左侧反射，<路径开始过度...

一团糟，但一团糟。:)

由Timwi的惊人HexagonyColorer生成的图。

摩托罗拉MC14500B机器代码，2个字节

十六进制：

58EC

说明：

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

摩托罗拉MC14500B是1位微控制器；它具有一个1位寄存器和一个1位数据总线。由于每个操作码都是4位，因此只有16位。它们中的一半在寄存器和数据总线上的位之间执行逻辑运算。

跳转指令设置跳转标志。当未提供地址时，通常将程序计数器设置为0。如果输入位为零，则处理器将不会跳转。如果输入位为1，则处理器跳回到起始位置；否则，输出为0。因为我们正在OR处理输入，所以输入什么信号都没关系-寄存器将永远为1。

按照常规，该寄存器初始化为0。

可以在数据表或此处找到操作码列表。

阿诺德C，296字节

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

竞争并不算真正，但是很有趣。不支持标准输入，替换@NO PROBLEMO用@I LIED零值。@No Problemo是1。

运行（假设文件为truemachine.arnoldc）：

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

Minecraft，18字节（MC版本15w45a）

如您所见，在重复命令块中有一个控制杆，其中包含命令say 1。最重要的是有一个信号反向割炬，它可以将功率引导到带有命令的单次运行命令块say 0中。

每当开关指向真实状态时，转发器块都会使用该代码say 1输出无限大的1s。当操纵杆重定向到false时，它输出一个0。

请注意，[@]默认情况下会输出a 。如果您确实只想将1和0向上取整，那么它将变为34字节，其中命令块中的代码为tellraw @a [1]和tellraw @a [0]。这是使用@CᴏɴᴏʀO'Bʀɪᴇɴ为MC建议的字节数，可以在Meta中找到。

Bash + GNU utils，13

grep 0||yes 1

Bash，35岁

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

Ruby，20岁

print while/1/||gets

从命令行运行以避免警告，如下

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

说明：

少打高尔夫球，这是

while /1/ || gets
  print
end

在条件表达式中使用Regexp时，除非变量$_已填充且与模式匹配，否则它的评估结果为false 。第一次通过循环时，$_为空，因此我们进入gets，将的值设置为$_从STDIN读取的行。print没有参数打印$_。现在，我们再次评估条件。如果我们读入1，则会短路并再次打印1，以此类推。否则，我们进入gets，但是由于没有第二行输入，gets返回nil，因此循环结束。

Microscript，3个字节

i{p

我知道的最短的一个。

说明：

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

Microscript在终止时隐式打印了寄存器1，这就是为什么输入0一次被打印的原因。

图灵机代码，32字节

使用此处找到的规则表语法。

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

JavaScript，28个字节

for循环通常比while循环短。

alert(x)回报undefined，这是falsy，所以按位或运算符，|，注塑它0。因此，如果x为"0"，则提醒一次，否则继续循环。使用alert像STDOUT 这个答案。

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

Python 2，29个字节

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

这将终止与分割误差0，这是默认允许的。

Brainfuck，41 36 31 30字节

输入后立即在Ethan和user46915的帮助下打印一次即可缩短。

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

以前的版本：从输入中减去48，如果它不为零，则将48加1以1永远打印ASCII ，否则打印0。

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

我在这里运行它，但是由于缓冲了输出，您看不到任何输出，因为该程序永不终止于1。

编辑：我忘了0在input 上打印0。立即修复。我喜欢最后的>.<面孔。

Piet，27 18 16编码

（Codel是一个奇特的像素名称，用于在拉伸图像以供查看时避免混淆。由于计数脚本被保存为图像，因此我计算了Codel而不是字节，因此物理尺寸可能会有所不同。我认为理想的文件格式可以节省此Piet尽可能高效地占用11个字节。实际上，我的gif文件只有62个字节，具有最佳的调色板数据。请告诉我是否应将其用作条目的大小而不是编码量。）

原始图片：

放大：

在piet中，两种颜色之间的差异决定了要运行哪个命令，因此两次看到相同的颜色并不意味着它执行相同的操作。执行从左上角的编解码器开始。然后它水平移动，执行以下操作：

1. 读一个数字并将其放在堆栈上
2. 复制堆栈顶部
3. 弹出并输出堆栈顶部
4. 弹出堆栈的顶部，然后顺时针旋转该次数。

如果输入为1，则光标会向下移动到石灰编码中，从而将1压入堆栈。然后执行继续向左移动。当光标从一种颜色变成白色，从白色变成一种颜色时，什么也没有发生。由于黑色也被视为墙，因此光标最终返回到第一行的石灰代码，并重复步骤2的整个过程。

但是，如果输入为0，则如果光标停留在该位置（因为顶部，右侧，左侧和顶部），则光标将永远不会向下移动，并最终会出现在右侧的蓝色J中（双关语是值得的）。此J形块的底边靠近黑色编码或图像边缘。由于光标被捕获，执行结束。

意外的值：
如果用户写了另一个数字，它仍然会被打印，然后光标将根据该值旋转或多或少的次数。

• 4或0的倍数：水平继续执行并结束。
• 3的倍数：由于不可能向上移动，因此光标立即沿顺时针方向旋转并继续水平移动，然后结束。
• 2的倍数，而不是4的倍数：光标旋转并开始向左移动。幸运的是，所有这些操作是执行了一系列不影响程序流程的操作，最终清空了堆栈。当由于堆栈为空而无法执行操作时，将被忽略。当它到达左上角时，光标别无选择，只能再向右移动，从而有效地重新启动程序。
• 其他值：光标向下移动，好像与1一样向下，这使其永远打印1。如果输入为5，则输出为5111111111111...

任何非整数值都将终止程序。执行将正常继续，但是由于堆栈中没有任何内容，所有操作将被忽略。因此，从某种意义上讲，该程序永远不会崩溃-它要么正常停止，要么永远循环。

PietDev友好版本

PietDev（一个非常基本的在线Piet IDE）似乎在使用白色编码时遇到了麻烦，因此我制作了一个新版本，该版本手动旋转回去，而不是依靠适当的白色编码自动旋转。而且我什至不需要使用新的颜色！如果要对其进行测试，请确保在代码周围绘制黑色边框，因为PietDev不支持自定义程序大小。

旧版本

第一个版本没有将1压入堆栈，而是循环回到了较早的复制指令。它也有装饰性的无用的代码。

然后我想到将1压入堆栈以删除空白行。多亏了我的装饰编码，我对它的想法感到很有趣。

然后我意识到我有了多余的重复项，我减少了颜色数量以节省图像中的调色板数据。我也摆脱了单一的装饰编码，因为我不知道。

Pyth， 4 3 2

Wp

有一个不！尾随空格（感谢isaac :)）。以前需要使while循环编译的空间，但是Pyth已更新。通常，这将取消使用它的资格，但是由于这是目录，因此它应该有效。

说明：

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

芯片，6字节

e*faAs

芯片是一种2D语言，其行为有点像集成电路。它一次只能输入一个字节，然后将这些位分解为各个输入元素。输出将输出元素的值缝合在一起，重新组合为字节。

让我们分解一下：

*是一个源信号，它将向所有相邻元素发送一个真实值。 e并f对应于输出的第五和第六位。因此，e*f产生binary 00110000，即ASCII字符“ 0”。

现在，A是输入a的第一位，是输出的第一位，因此aA将该位从输入复制到输出。因此，当与组合使用时e*f，ASCII输入“ 0”将产生“ 0”，而“ 1”将产生“ 1”。（f和之间没有交互a，因为两者都不会产生任何信号。）

在s上月底，一个真正的信号启动时，将阻止前进到下一个字节，这意味着整个事情会以相同的输入再次运行输入。

由于“ 0”的第一个字节为零，因此它将不会激活该元素，并且程序将打印“ 0”，从而耗尽其输入，从而使其终止。但是，“ 1”激活此元素，这意味着将输出“ 1”，但不会在输入上消耗“ 1”，从而允许循环无限期重复。

如果使用值0x0和0x1而不是ASCII进行输出，我们可以删除该e*f部分，仅产生3个字节：

aAs

如果零必须自己终止，而不是期望stdin关闭，我们将得到以下代码，该代码用反转第一个字节~，并将结果传递给t，从而终止程序（10个字节）：

aA~te*f
 s

（t也不会产生信号，因此tand 之间没有交互e。）

Brainbool，5个字节

,.[.]

Brainbool是Brainfuck，但它仅对位起作用，并且通过0和1字符进行I / O。

LOLCODE，119个字节

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

取消高尔夫：

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个字节

在C中如何做的另一种看法。

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

c默认为1 int的值。gets(&c)从那里获取一个字符串stdin，在这里破坏了值c，因为c它不是a char*。putchar(c)打印cto 的值stdout，并返回c。因为'0'是48，'1'ASCII中是49，所以我们可以使用最后一位（&1）来确定它是哪个。如果是'0'，则循环中断。否则，它将永远存在。

编译（带有的警告gets）并gcc-4.8在Linux上运行。

迷宫，7字节

 ?+
@!:

迷宫是一种基于2D堆栈的语言，其中控制流取决于堆栈顶部元素的符号，每条指令后都要检查。执行从最上面一行的第一条有效指令开始向右移动?。

相关说明是：

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

如果输入为0，则IP读取带有的输入?，将堆栈的顶部两个（0 + 0 = 0）相加，然后复制:并输出!0。在这里，我们在程序中遇到唯一的结点，必须检查堆栈的顶部以确定去哪儿。由于顶部为0，因此我们向前移动并以终止@。

另一方面，如果输入为1，则在到达处的结点之前，我们会执行与之前相同的指令（但输出为1）!。现在，堆栈顶部为正，导致我们右转到?。在EOF上，迷宫推0，因此我们0 + 1 = 1在+，重复:和输出处执行操作!。再一次，我们在堆栈的顶部有一个1，循环继续。

作为奖励，这是@MartinBüttner的7字节解决方案，其操作类似：

?+!@
1!

请注意，与大多数语言不同，1实际上是从n堆栈中弹出并压入n*10 + 1，使大量的构建变得容易。但是，由于此时栈顶是空的，因此与仅压入1没有什么不同。

> <>，7个字节

i2%:n:,

这利用了一个事实，即> <>在EOF上将-1推为1 mod2。它还使用除以0来终止（这显然是可以的，因为共识是忽略了STDERR输出）。

仅供参考，干净无误地退出是一个额外的字节：

i2%:n?!;

APL，6个字节

→⎕←⍣⍲⎕

说明：

     ⎕ 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个字节

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

在此，<SOH>应替换为相应的控制字符（0x01）。

说明

基本思想是从pChuck的末尾减去输入的字符代码（48或49），这将给出一个?（有效命令）或@一个无操作符。

,将输入字符读取到Chuck的第一个单元格中（标有_）。我们希望将此值递减到0一个循环，同时进行其他一些更改：

}<移至p并-递减。然后，{移回输入单元格也将-递减。只要还不为零，?就将控制权交给查克。现在>将Brian的磁带头向右移动一个单元格（已初始化为1）并将其+递增。然后，用重置循环{?。

通过对查克的第一个单元格命中的时候0，该<SOH>电池将一直递增到我们从标准输入读和角色p将是?输入1或@输入0。

现在?不再切换控制。的0或1以后它是一个空操作，由于是空字节（由表示_）。{移回Chuck的第一个单元格并+递增以确保其为正数，这样，?双手可以控制Chuck。

此时间>+在Brian的初始录像带结束后增加了单元格。该单元格是垃圾，但我们永远不会使用它。现在{，不会一直扫描到Brian磁带的前端，而只会扫描到_。因此?是空操作，因为当前单元格为零。然后<.向左移动一个（输入字符的副本）并打印。

最后，我们遇到?或@。如果输入是，0并且此单元格为@空，则程序终止。但是如果输入的是1该单元格，那么?我们将移交给Brian，Brian {+?将重置Chuck上的循环，现在我们将1永远打印s（直到Brian磁带结尾的单元格中的整数不适合任何内存更多，我想...）。

奖金

Sp3000和我在这方面打了几天球。我们从大约40个字节开始，然后得出了两个完全不同的但捆绑在一起的26个字节的解决方案。只有当我开始撰写我的说明时，我才想到上面的21字节解决方案。非常感谢Sp在B＆C中提出想法并互相教一些高尔夫技巧。:)

这是他的26字节解决方案：

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

这是我的：

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

®值174的字节在哪里（例如，仅将文件另存为ISO 8859-1）。

在核心上，我的工作方式类似于21字节的解决方案，因为它®成为}输入1，~（无操作）为输入0，但是执行起来不那么优雅。

他的解决方案非常简洁，因为源代码仅为ASCII，并且不需要循环即可处理输入。相反，----转1成-和0成,（无操作查克）。-然后，这会将?Brian磁带上的第一个更改为>，从而为1-case 创建不同的控制流。

按位循环标记，3位或<1个字节

按位循环标记是最简单的图灵完备语言之一。它使用两个位串，程序和数据。程序的位循环读取并解释如下：

• 0：删除第一个数据位（并在有输出的实现中输出）。
• 1x：如果第一个数据位是1，则在数据末尾附加x（代表0或1）。（如果第一个数据位是0，则不执行任何操作。）

程序将运行直到数据字符串为空。

真机

110

当数据字符串设置为时0：

• 11不会附加任何内容，因为第一个数据位不是1。
• 0删除/输出0。
• 数据字符串现在为空，程序停止。

当数据字符串设置为时1：

• 11附加一个1。
• 0删除/输出1。
• 数据字符串返回到单个字符串1，程序返回到它开始的位置，因此我们永远循环。

GNU sed，10岁

:;/1/{p;b}

说明

• : 定义一个未命名的标签
• /1/如果输入匹配正则表达式1，则
• p 打印图案空间（即1）
• b 然后跳回未命名的标签（永远）
• 如果输入不为1（即0），则图案空间将按原样打印并结束程序。

严重的是，4 3个字节

_{划掉的4仍然是4 :(}

,W■

,从STDIN读取一个值。W使用body启动一个循环，当堆栈顶部的值为true时运行■。■打印顶部堆栈元素而不会弹出。该循环在EOF处隐式关闭。

输入时0，循环将永远不会执行（因为0为false），并且程序在EOF结束，并自动弹出并打印堆栈中的每个值。上的输入1（或不是任意值0，""或[]），该无限循环运行。

在实际上，领先的,是不需要（感谢隐含的输入），使比分到2个字节。

Thue，34个字节

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

说明：

1::=12 子字符串“ 1”的实例可以变为“ 12”

2::=~1 可以删除子字符串“ 2”的实例，并显示“ 1”

0::=~0 可以删除子字符串“ 0”的实例，并显示“ 0”

@::=::: 子字符串“ @”的实例可以替换为输入中的字符串

::= 替代规则的结束列表

@ 初始字符串为“ @”

Arnold C，134个字节

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

虽然这不像其他ArnoldC 答案那么有趣，但它是高尔夫球。例如，缩进是不必要的，宏@NO PROBLEMO和也是如此@I LIED。

已使用此语言版本进行测试，该语言无法接受输入。

Cubix，5 6字节

Cubix是@ETHproductions的新型二维语言，其中的命令环绕在多维数据集的表面。在线解释器 感谢@ETHproductions的保存。

!I\@O

最终扩展到多维数据集

  !
I \ @ O
  .

这从I命令开始。输入一个整数到堆栈上。
\，将指令指针向下重定向到no op。
O，输出堆栈顶部的数值。
!，@如果堆栈顶部为true ，则跳过下一个命令（）。\如果为1
\，则将跳转重定向，将指令指针重定向到@退出程序。

这利用了O ? !命令未弹出堆栈的事实。

Foo，6个字节

&1($i)

输入被硬编码为第二个字符，因为Foo没有STDIN输入。我们不同意Foo现在很棒吗？:)

说明

&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字节

print while$_

像这样运行：

echo -n NUM | perl -p truth.pl

感谢ThisSuitIsBlackNot（在Perl打高尔夫球中比我更好的人）打了五个字节。

> <>，6个字节

::n?!;

将输入压入堆栈以开始

:        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