Правда машина (кредиты идут к этому парню , что пришли с ним) очень простой программой , предназначенной для демонстрации ввода / вывода и управления потоком языка. Вот что делает машина правды:

• Получает число (0 или 1) из STDIN.

• Если это число равно 0, распечатайте 0 и завершите.

• Если это число равно 1, выведите 1 навсегда.

Вызов

Напишите машину правды, как описано выше, на выбранном вами языке. Машина истины должна быть полной программой, которая следует этим правилам:

• принять вход от STDIN или приемлемой альтернативы
  • Если ваш язык не может получить ввод из STDIN, он может получить ввод из жестко закодированной переменной или подходящего эквивалента в программе
• должен выводить на STDOUT или приемлемую альтернативу
  • Если ваш язык не способен выводить символы 0или 1, байтовый или унарный ввод / вывод приемлем.
• при вводе 1он должен постоянно печатать 1s и останавливаться, только если программа убита или не хватает памяти

• вывод должен быть либо с 0последующим либо одним, либо без новой строки или пробела, либо с бесконечным 1s, 1за которым следует либо один, либо без новой строки или пробела. Никакие другие выходные данные не могут быть сгенерированы, кроме постоянного вывода интерпретатора вашего языка, который не может быть подавлен (например, приветствие, цветовые коды ANSI или отступ). Ваше использование новых строк или пробелов должно быть согласованным: например, если вы решите выводить 1с новой строкой после всех 1, после них должна быть новая строка .

• тогда и только тогда, когда ваш язык не может завершиться на входе 0, допустимо, чтобы код входил в бесконечный цикл, в котором ничего не выводится.

Поскольку это каталог, языки, созданные после этого конкурса, могут конкурировать. Обратите внимание, что должен быть переводчик, чтобы представление можно было проверить. Разрешается (и даже поощряется) самостоятельно писать этот переводчик для ранее не реализованного языка. Кроме этого, все стандартные правила код-гольфа должны соблюдаться. Материалы на большинстве языков будут оцениваться в байтах в соответствующей существующей кодировке (обычно UTF-8).

Каталог

Фрагмент стека в нижней части этого поста создает каталог из ответов а) в виде списка кратчайшего решения для каждого языка и б) в качестве общей таблицы лидеров.

Чтобы убедиться, что ваш ответ обнаружен, начните его с заголовка, используя следующий шаблон уценки:

## 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 байт

Это было удивительно сложно, и я не уверен, что это оптимально ...

<.@!$?

После дополнения и развертывания кода это представляет следующую шестнадцатеричную сетку:

При этом используется тот же поток управления, что и в моей недавней безошибочной программе для кошек , движущейся по антидиагоналам. Чтобы добиться этого, мы начинаем с отклонения указателя инструкций (IP) влево, где фиолетовый путь оборачивается в нижний левый угол.

?читает входные данные как целое число. !печатает его обратно. .это просто неоперация. Теперь угол сетки действует как ветвь:

Если вход был 0, IP будет продолжаться по красной дорожке, которая просто завершает программу с @.

Если вход был 1, IP будет продолжаться по зеленому пути. Опять же, .это просто запрет, но $это эквивалент батута Бефунге: он пропускает следующую инструкцию. После переноса следующей инструкцией будет ?, но из-за $выполнения фактически продолжается синий путь, начиная с !печати другой копии 1. Этот цикл, который только содержит !..$, теперь повторяется бесконечно.

Исследование потока управления в шестиугольнике ...

Я считаю, что вышеуказанное решение является оптимальным. Я написал брутфорсер, который проверяет все 6-байтовые программы Hexagony, которые содержат по крайней мере одну из них ?!@(которые необходимы; я также проверил :и %вместо того, @чтобы завершить с ошибкой деления на ноль, но это тоже не помогло). Проверка печатает все программы, которые a) выдают 0на входе 0и завершают, и b) выдают по крайней мере два 1с (и ничего больше) и не завершаются в течение первых 60 тактов программы (200 тактов для 5-байтовых решений) , Я сомневаюсь, что любое правильное решение потребовало бы более 200 тиков, чтобы правильно напечатать первое 0или второе 1на такой маленькой сетке, поэтому я не думаю, что упустил какие-либо потенциальные решения.

Поиск не дал никаких результатов для 5 байтов, но 57 результатов для 6 байтов (используя @; нет необходимости завершать с ошибкой, если мы можем решить это чисто в том же количестве байтов). Из этих 57 только 6 были ложными срабатываниями, которые фактически напечатали только два 1с, а затем вошли в бесконечный цикл, не печатая больше. Одно решение было указано дважды, поскольку оно содержало две !команды. Это оставляет ровно 50 действительных решений.

Существует определенная степень вырождения между решениями, в которых один или два символа несущественны, например потому, что они в любом случае фактически не работают. Решения могут быть сгруппированы в 23 набора действительно различных программ (в некоторых случаях разница между двумя наборами составляет всего один символ, но это существенно меняет поток управления, поэтому я их подсчитал отдельно). Две группы даже используют несколько указателей инструкций очень неожиданным образом. Поскольку я никогда не смог бы придумать большинство из этих способов использования ветвей и зеркал, они очень интересно изучают, какие виды управления потоками возможны в гексагонии, и я определенно изучил некоторые новые приемы для будущих гольфов.

Общий поток управления почти всегда одинаково: читать номер, распечатать его. Если это 0найти путь к @, если нет, продолжайте циклически проходить !при сохранении значения ребра 1. Есть четыре заметных исключения:

• Одно решение (одно с двумя !) печатает два 1s за итерацию по сетке, поэтому печатает примерно в два раза быстрее, чем большинство программ. Я отметил это x2ниже.
• Несколько решений (те , которые содержат o) заменить 1с 111(символьным кодом o), поэтому они печатают три 1 с на итерацию, что делают их напечатать примерно в три раза быстрее, чем в большинстве программ. Я пометил их 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 стоит проверить. В других группах есть много других интересных и порой запутанных путей, но я думаю, что в конце этого вам достаточно скучно. Для тех, кто действительно хочет изучать гексагонию, их, безусловно, стоит исследовать, поскольку они демонстрируют еще более возможное использование зеркал и $.

Группа 1

Это не намного сложнее, чем мое первоначальное решение, но пути идут в разных направлениях. Это также учитывает наибольшее количество вариантов в одной ячейке, так как самый правый неоперативный объект может быть заменен 5 различными командами, которые все еще делают это действительным без изменения структуры:

Группа 2

Этот довольно интересный, потому что он движется только горизонтально. После перехода к >IP-адрес сразу же меняется на противоположный, принимая ветку в углу. Это не совсем хорошо видно на диаграмме, но в случае 1мы снова пересекаем первый ряд, но на этот раз в обратном направлении. Это также означает, что мы сталкиваемся ?снова, который теперь возвращает 0(EOF). Это исправлено с )(приращением), чтобы сохранить печать 1s. Это также имеет 5 вариантов, которые )также могут быть 1или o, и >также могут быть |:

Группа 3

Это выглядит почти идентично предыдущему, но чертовски грязно. До удара, |а затем прохождения нижнего или верхнего ряда это то же самое. Но в случае цикла, $теперь пропускается ) на зеркало. Таким образом, мы идем по бирюзовой дорожке направо, теперь нажимаем на приращение, пропускаем все @до того, как | снова обернемся, а затем возвращаемся к зеленой дорожке наверху.

Группа 4

Я думал, что это было особенно изящно:

_Зеркало в верхнем правом углу не является изначально не-оп, поэтому мы печатаем с !и ударил <. Теперь 0путь попадает в горизонтальное зеркало и заканчивается. 1Путь занимает очень интересную траекторию , хотя: она отклоняется вниз, заворачивает к !, перенаправляется в сторону по горизонтали , а затем заворачивает назад к ! снова . Затем он продолжает двигаться в форме ромба, печатая дважды за итерацию (каждый третий тик).

Группа 8

Это одно из двух решений с очень плотным циклом печати:

В <выступает в качестве филиала. После оборачивания дважды, 0удары @. 1с другой стороны, сначала пропускает ?, затем снова >отправляет его на $, то есть пропускает @. Затем IP оборачивается в бирюзовый путь, где он подпрыгивает назад и вперед между >и <(обтекание края между ними).

Группа 10

Одна из двух групп, которые используют другие указатели инструкций, и это абсолютно красиво. Гексагония имеет 6 - каждый начинается с другого угла по краю по часовой стрелке, но одновременно активен только один из них.

Как обычно, мы читаем с ?. Теперь ~унарное отрицание: оно превращается 1в -1. Далее мы попали #. Это один из способов переключения между IP-адресами: он принимает текущее граничное значение по модулю 6 и переключается на соответствующий IP-адрес (IP-адреса нумеруются 0по часовой стрелке). Так что, если вход был 0, то IP просто остается прежним, и скучно идет прямо вперед !@. Но если вход был 1, то текущее значение, -1которое есть 5 (mod 6). Поэтому мы переключаемся на IP, который начинается в той же ячейке (зеленый путь). Сейчас #не работает и ?устанавливает край памяти на 0. )увеличивает, так что !печатает 1. Теперь мы ~снова ударили, чтобы убедиться, что#до сих пор не работает (в отличие от переключения на IP 1, который завершит программу). Удивительно, насколько хорошо все сочетается в этой маленькой программе.

Группа 22

Просто отметим, что это группа, в которой находится мое первоначальное решение. Это также самая большая группа, потому что no-op может находиться в двух разных местах, и есть несколько вариантов для действительной (действующей no-op) команды.

Группа 23

Это другая группа, использующая несколько IP-адресов. На самом деле этот использует 3 разных IP. В верхнем правом углу немного беспорядка, но я постараюсь провести вас через это:

Итак, начало, которое вы видели раньше: <отклоняет северо-восток, ?читает ввод. Теперь ]есть еще один способ переключения между IP-адресами: он передает управление следующему IP-адресу по часовой стрелке. Таким образом, мы переключаем управление на бирюзовый путь, который (я знаю, что это трудно увидеть) начинается в северо-восточном углу юго-востока. Это сразу же отражается <тем, что оно охватывает юго-восточный угол, идущий на северо-запад. Это также ударил, ]поэтому мы переключаемся на следующий IP. Это серая тропа, начинающаяся в восточном углу и идущая на юго-запад. Он печатает ввод, затем переносится в северо-восточный угол. <отклоняет путь в горизонтальное положение, где он отражается другим < . Теперь правая рука<действует как ветвь: если вход был 0, IP перемещается на северо-восток и переносится на @. Если вход был 1, IP перемещается в !, оборачивается в левую и <там, где он отражается ... теперь в углу, он оборачивается обратно в !, отклоняется вправо <, отражается слева <и начинается путь над...

Довольно беспорядок, но красивый беспорядок. :)

Диаграммы, созданные с помощью удивительного HexagonyColorer Тимви .

Motorola 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

Motorola MC14500B - это 1-битный микроконтроллер; он имеет один 1-битный регистр и 1-битную шину данных. Поскольку коды операций имеют 4 бита каждый, их всего шестнадцать; половина из них выполняет логическую операцию между регистром и битом на шине данных.

Инструкция перехода устанавливает флаг перехода; если адрес не указан, обычно устанавливается счетчик программы равным 0. Если входной бит был равен нулю, процессор не скачет. Если бит ввода равен 1, процессор возвращается к началу; так как мы работаем ORсо входом, то не имеет значения, какой будет входной сигнал после этого - регистр будет равен 1 всегда.

Как обычно, регистр инициализируется в 0.

Список кодов операций можно найти в техпаспорте или здесь .

Арнольд С, 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

Не очень конкурентоспособный, но для удовольствия. Не поддерживает STDIN, заменить @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.

Обратите внимание, что это выводит [@]по умолчанию. Если вы действительно хотите получить только 1 и ноль, это становится 34 байта, где код в командных блоках tellraw @a [1]и tellraw @a [0]. Для этого используется счетчик байтов @ Cᴏɴᴏʀ O'Bᴏɴᴏʀ для MC, который можно найти в Meta .

Утилиты Bash + GNU, 13

grep 0||yes 1

Баш, 35

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

Руби, 20

print while/1/||gets

Запускайте из командной строки, чтобы избежать предупреждений, так как

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

Объяснение:

Менее гольф, это

while /1/ || gets
  print
end

Когда регулярное выражение используется в условном выражении, оно оценивается как ложное, если переменная $_не заполнена и не соответствует шаблону. В первый раз в цикле $_пусто, поэтому мы переходим к gets, что устанавливает значение $_строки, считываемой из STDIN. printбез аргументов печатает $_. Теперь мы снова оцениваем условное. Если мы читаем в 1, мы закорачиваем и просто печатаем 1 снова, и так далее навсегда. В противном случае мы переходим к gets, но поскольку нет второй строки ввода, getsвозвращает ноль, поэтому цикл заканчивается.

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 байт

Поскольку петли часто короче, чем в то время как петли.

alert(x)Возвращает undefined, что ложно, поэтому побитовое или оператор |, приводит его к 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 байт

Укорочено печатью сразу после ввода и с помощью Итана и пользователя 46915.

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

Предыдущая версия: вычтите 48 из входных данных, и, если это не ноль, добавьте 1 к 48, чтобы напечатать ASCII 1навсегда, иначе напечатайте 0.

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

Я запустил его здесь , но из-за буферизованного вывода вы не можете видеть никакого вывода, так как программа никогда не завершается 1.

Изменить: я забыл напечатать 0на входе 0. Исправлено сейчас. Мне нравятся >.<лица в конце.

Пит, 27 18 16 кодов

(Codel - причудливое название для пикселя, используемое, чтобы избежать путаницы при растягивании изображения для просмотра. Я посчитал коделы вместо байтов, потому что сценарии Piet сохраняются в виде изображений, поэтому физический размер может отличаться. этот фрагмент максимально эффективно занимал бы 11 байт. На практике мой крошечный gif-файл составляет 62 байта с оптимальными данными палитры. Скажите, должен ли я использовать это в качестве размера моей записи вместо объема кодела.)

Исходное изображение:

Увеличенный:

В piet разница между двумя цветами определяет, какая команда запускается, поэтому, если дважды увидеть один и тот же цвет, это не означает, что он выполняет одно и то же действие. Выполнение начинается в верхнем левом коде. Затем он движется горизонтально, выполняя следующее:

1. Прочитайте число и положите его в стек
2. Дублируйте вершину стека
3. Pop и выводит верх стека
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

Существует нет! завершающий пробел (спасибо Айзеку :)). Раньше для компиляции цикла 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

Чип - это двумерный язык, который немного похож на интегральную схему. Он принимает входные данные по одному байту за раз и разбивает биты на отдельные входные элементы. Выходные данные объединяют значения выходных элементов обратно в байты.

Давайте разберем это:

*является исходным сигналом, он отправит истинное значение всем соседним элементам. eи fсоответствуют пятому и шестому битам выхода. Итак, e*fвыдает двоичный файл 00110000, который является ASCII-символом "0".

Теперь Aэто первый бит ввода и aпервый бит вывода, поэтому aAкопирует этот бит с входа на выход. Таким образом, в сочетании с e*f, вход ASCII «0» выдает «0», а «1» выдает «1». (Нет взаимодействия между fи a, так как ни один не производит никакого сигнала.)

sНа конце, при активации истинного сигнала, предотвратит вход с переходом к следующему байту, а это означает , что все это будет работать снова с тем же входом.

Поскольку первый байт «0» равен нулю, он не активирует этот элемент, и программа выведет «0» и тем самым исчерпает свой ввод, что позволяет ему завершиться. «1», однако, активирует этот элемент, что означает, что «1» выводится, но не расходуется на входе, что позволяет циклу повторяться бесконечно.

Если для вывода используются значения 0x0 и 0x1, а не ASCII, мы можем исключить e*fчасть, получив в результате только 3 байта :

aAs

Если ноль должен завершиться сам, а не ожидать закрытия stdin, мы получим следующее, которое инвертирует первый байт с ~и передает результат t, который завершает программу ( 10 байт ):

aA~te*f
 s

( tтакже не выдает сигнал, поэтому нет взаимодействия между tи e.)

Brainbool , 5 байтов

,.[.]

Brainbool - это Brainfuck, но он работает только с битами, вводом-выводом 0и 1символами.

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

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 байт

Другой взгляд на то, как это сделать на C.

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

cзначение по умолчанию - intзначение 1. gets(&c)получает строку stdin, которая здесь ударяется о значение c, как cэто ни странно char*. putchar(c)печатает значение cдо stdoutи возвращает c. Так '0'как 48 и '1'49 в ASCII, мы можем использовать последний бит ( &1), чтобы определить, что это такое. Если это так '0', цикл обрывается. В противном случае, это идет навсегда.

Компилирует (с предупреждением о gets) и работает под gcc-4.8Linux.

Лабиринт , 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 Labyrinth нажимает 0, поэтому мы делаем 0 + 1 = 1на +, дублировать :и выводить !. Еще раз у нас есть 1 на вершине стека, и цикл продолжается.

Для бонуса предлагаем 7-байтовое решение @ MartinBüttner, которое работает аналогично:

?+!@
1!

Обратите внимание, что, в отличие от большинства языков, 1фактически выталкивается nиз стека и выталкивает n*10 + 1, что облегчает создание больших чисел. Однако, поскольку верхняя часть стека в этот момент пуста, она ничем не отличается от простого нажатия 1.

> <> , 7 байт

i2%:n:,

При этом используется тот факт, что> <> помещает -1 в EOF, что равно 1 модулю 2. Он также использует деление на 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.

Брайан и Чак , 21 байт

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

Здесь <SOH>следует заменить соответствующий управляющий символ (0x01).

объяснение

Основная идея состоит в том, чтобы вычесть код символа ввода (48 или 49) из pконца в конце Чака, который либо даст ?(что является допустимой командой), либо a, @который не используется.

,читает входной символ в первую ячейку Чака (отмечен значком _). Мы хотим уменьшить это значение до 0цикла, в то же время внося некоторые другие изменения:

}<движется к pи -уменьшает его. Затем {возвращается к -уменьшению входной ячейки, что также. Пока это еще не ноль, ?дает контроль Чаку. Теперь >перемещает головку ленты Брайана на одну ячейку вправо (которая инициализируется 1) и +увеличивает ее. Затем мы сбрасываем цикл с помощью {?.

К тому времени , когда первая клетка на Чаке ударяется 0, то <SOH>ячейка будет уже увеличена до символа мы читаем из STDIN и pбудем ?для ввода 1или @для ввода 0.

Теперь ?больше не переключает управление. Знак 0или 1после него не используется, как и нулевой байт (представлен _). {возвращается к первой ячейке Чака и +увеличивается, чтобы убедиться, что она положительна, так что ?руки контролируют Чака.

Это время >+увеличивает ячейку после окончания начальной ленты Брайана. Эта клетка - мусор, но мы никогда не будем ее использовать. Теперь {сканирует не весь путь до ленты Брайана, а только до _. Следовательно, ?не работает, потому что текущая ячейка равна нулю. Затем <.перемещается на одну влево (копия входного символа) и печатает его.

Наконец, мы сталкиваемся с ?или @. Если вход был 0и эта ячейка - @это неоперация, и программа завершается. Но если вход был 1и эта ячейка - ?мы передаем Брайану, {+?который сбросит цикл на Чаке, и теперь мы печатаем 1s навсегда (пока целое число в ячейке в конце ленты Брайана не поместится в память. больше, я полагаю ...).

бонус

Sp3000 и я играли в гольф на этом в течение нескольких дней. Мы начали с 40 байтов и получили два совершенно разных, но связанных решения с 26 байтами. Только когда я начал писать свое объяснение, 21-байтовое решение, приведенное выше, пришло мне в голову. Большое спасибо Sp за то, что он бросил идеи и научил друг друга некоторым трюкам игры в гольф в B & C. :)

Это его 26-байтовое решение:

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

И это мое

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

Где ®находится байт со значением 174 (например, просто сохраните файл как ISO 8859-1).

В основном шахта работает аналогично 21-байтовому решению, в котором ®делается }для ввода 1и ~(без операции) для ввода 0, но выполнение гораздо менее элегантно.

Его решение довольно изящно в том, что исходный код предназначен только для ASCII и что для обработки ввода не требуется цикл. Вместо этого ----превращается 1в -и 0в ,(не для Чака). Это -тогда изменит первый ?на ленте Брайана на >, создавая тем самым другой поток управления для 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запускает цикл, который выполняется, пока значение на вершине стека истинно, с телом ■. ■печатает верхний элемент стека без выталкивания Цикл неявно замкнут в EOF.

При вводе 0цикла цикл никогда не выполняется (поскольку он 0имеет тип false), и программа заканчивается в EOF, автоматически выталкивая и печатая каждое значение в стеке. На входе 1(или любое значение, которое не 0, ""или []), то цикл выполняется бесконечно.

На самом деле , ведение ,не требуется (благодаря неявному вводу), в результате чего счет уменьшается до 2 байтов.

Чт, 34 байта

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

Объяснение:

1::=12 Экземпляры подстроки "1" могут стать "12"

2::=~1 Экземпляры подстроки "2" можно удалить, напечатав "1"

0::=~0 Экземпляры подстроки «0» можно удалить, напечатав «0»

@::=::: Экземпляры подстроки "@" могут быть заменены на строки из ввода

::= Конечный список правил замещения

@ Начальная строка "@"

Арнольд С, 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, выводит числовое значение вершины стека.
!, пропустите следующую команду ( @), если вершина стека верна. Это переместит \перенаправление, если 1
\, перенаправит указатель команды на программу @выхода.

Это использует тот факт, что стек не выталкивается O ? !командами.

Foo , 6 байт

&1($i)

Ввод жестко закодирован как второй символ, так как Foo не имеет ввода STDIN. Разве мы не согласны с тем, что Фу теперь великолепен? :)

объяснение

&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