Правда машина (кредити йдуть до цього хлопця , що прийшли з ним) дуже простий програмою , призначеної для демонстрації введення / виведення і управління потоком мови. Ось що робить машина правди:

• Отримує число (або 0, або 1) від STDIN.

• Якщо це число 0, роздрукуйте 0 та припиніть.

• Якщо це число 1, роздрукуйте 1 назавжди.

Виклик

Напишіть машину правди, як описано вище, вашою мовою на вибір. Машина істини повинна бути повноцінною програмою, яка дотримується цих правил:

• приймати дані від STDIN або прийнятної альтернативи
  • Якщо ваша мова не може приймати дані з STDIN, вона може взяти введення з твердо кодованої змінної або відповідного еквівалента програми
• повинен вивести STDOUT або прийнятну альтернативу
  • Якщо ваша мова не здатна виводити символи 0або 1, байтове або одинарне введення / виведення є прийнятним.
• коли вхід є 1, він повинен постійно друкувати 1s і зупинятися лише в тому випадку, якщо програма знищена або не вистачає пам'яті

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

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

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

Каталог

Фрагмент стека внизу цієї публікації генерує каталог з відповідей а) як список найкоротших варіантів для кожної мови та б) як загальний таблиця лідерів.

Щоб переконатися, що ваша відповідь відображається, будь ласка, почніть свою відповідь із заголовка, використовуючи наступний шаблон 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 байт

Це було напрочуд хитро, і я не переконаний, що це оптимально ...

<.@!$?

Після прокладки та розгортання коду це являє собою наступну шістнадцяткову сітку:

Для цього використовується аналогічний потік керування, як у моєї недавньої програми без кішок , що рухається по діагоналях. Для цього ми починаємо, відхиливши вказівник інструкції (IP) зліва, де фіолетова доріжка обертається до лівого нижнього кута.

?читає вхід як ціле число. !друкує його назад. .це просто неоперація. Тепер кут сітки виступає як гілка:

Якщо вхід був 0, IP буде продовжуватися по червоному шляху, який просто припиняє програму @.

Якщо вхід був 1, IP буде продовжуватися зеленим шляхом. Знову ж таки, .це просто $бездіяльність , але це еквівалент батуту Бефунге: він пропускає наступну інструкцію. Після завершення обговорення наступною інструкцією буде те ?, але завдяки $виконанню насправді продовжується синім шляхом, починаючи з !друку іншої копії 1. Цей цикл, який містить лише !..$зараз, повторюється нескінченно.

Дослідження контрольного потоку в Гексагоні ...

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

Пошук не дав жодних результатів для 5 байт, але 57 результатів для 6 байт (використовуючи @; немає необхідності припиняти помилку, якщо ми можемо вирішити це чисто в тій же кількості байтів). З цих 57 лише 6 були помилковими, які насправді надрукували лише два 1s, а потім увійшли до нескінченного циклу, не друкуючи більше. Одне рішення було перераховано двічі, оскільки воно містило дві !команди. Це залишає рівно 50 дійсних рішень.

Існує певна кількість виродженості між рішеннями, коли один або два символи не є істотними, наприклад, тому що вони фактично не спрацьовують. Рішення можна згрупувати в 23 набори справді відмінних програм (в деяких випадках існує лише одна різниця символів між двома наборами, але це суттєво змінює потік управління, тому я їх порахував окремо). Дві групи навіть користуються декількома вказівниками вкрай несподівано. Оскільки я б ніколи не придумав більшість цих способів використання гілок і дзеркал, вони роблять дуже цікаве вивчення можливих видів контрольного потоку в Гексагоні, і я, безумовно, навчився деяких нових хитрощів для майбутніх гольфів.

Загальний потік управління майже завжди однаково: читати номер, роздрукувати його. Якщо він 0знайде спосіб до @, якщо не продовжувати циклічно !, зберігаючи значення краю 1. Є чотири помітні винятки:

• Одне рішення (одне з двома !) друкує два 1с за ітерацію через сітку, тому друкується приблизно вдвічі швидше, ніж більшість програм. Я це позначив 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на a -1. Далі ми натискаємо на #. Це один із способів перемикання між IP-адресами: він приймає поточне значення по модулю 6 і переходить на відповідний IP (IP-адреси нумеруються 0за годинниковою стрілкою). Отже, якщо вхід був 0, то IP просто залишається тим самим і їде нудно прямо вперед !@. Але якщо вхід був 1, то поточне значення таке, -1яке є 5 (mod 6). Таким чином, ми переходимо до IP, який починається з тієї самої комірки (зелений шлях). Тепер #не працює і ?встановлює межу пам'яті 0. )з кроком, так що !друкується a 1. Тепер ми ~знову вдаримося, щоб забезпечити це#все ще не працює (на відміну від переходу на IP 1, що припинить програму). Це розумне те, наскільки добре все вписується в цю маленьку програму.

22 група

Зауважимо лише, що це група, в якій знаходиться моє оригінальне рішення. Також трапляється найбільша група, тому що неоперативний режим може знаходитися в двох різних місцях, і є кілька варіантів для фактичної (ефективної безвідмовної) команди.

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. Коли важіль переспрямований на помилковий, він видає одиничний 0.

Зауважте, що це виводиться [@]за замовчуванням. Якщо ви дійсно хочете просто підняти 1 і нулі, це стає 34 байтами, де код і в командних блоках є tellraw @a [1]і tellraw @a [0]. Для цього застосовується запропоноване число байтів для МС @ Cᴏɴᴏʀ O'Bʀɪᴇɴ, як це можна знайти в 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

Коли Regexp використовується в умовному режимі, він визначається як фальси, якщо змінна $_не заповнена і не відповідає шаблону. Перший раз через цикл $_порожній, тому ми потрапляємо до gets, що задає значення $_рядку, прочитаному з STDIN. printбез аргументів, друкує $_. Тепер ми знову оцінюємо умовне. Якщо ми читаємо в 1, ми коротко замикаємось і просто надруковуємо 1 знову і так далі назавжди. Інакше ми переходимо до gets, але оскільки немає другого рядка введення, getsповертається нуль, тому цикл закінчується.

Мікроскрипт, 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

Мікроскрипт має неявну друк регістру 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 байт

Скорочується шляхом друку один раз після введення даних та за допомогою Ethan та user46915.

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

Попередня версія: відніміть 48 від введення, і якщо він не дорівнює нулю, додайте 1 до 48, щоб надрукувати ASCII 1назавжди, інакше друкуйте 0.

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

Я запустив його сюди , але через буферизований вихід ви не бачите жодного виводу, оскільки програма ніколи не закінчується 1.

Редагувати: я забув надрукувати 0при вступі 0. Виправлено зараз. Мені подобаються >.<обличчя в кінці.

Піт, 27 18 16 коделів

(Codel - фантастичне ім’я пікселя, яке використовується для уникнення плутанини, коли зображення розтягується для перегляду. Я рахував коделі замість байтів, оскільки піксельні сценарії зберігаються як зображення, тому фізичний розмір може змінюватися. Я думаю, що ідеальний формат файлу, який би врятував цей пієт максимально ефективно зайняв би 11 байт. На практиці мій крихітний файл gif становить 62 байти, з оптимальними даними палітри. Скажіть, чи слід використовувати це як розмір мого запису замість кількості коделів.)

Оригінальне зображення:

Збільшено:

У пієті різниця між двома кольорами - це те, що визначає, яка команда виконується, тому побачити один і той же колір два рази не означає, що він робить одну і ту ж дію. Виконання починається у верхньому лівому коделі. Потім він рухається горизонтально, виконуючи наступне:

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

Чіп - це двовимірна мова, яка трохи схожа на інтегральну схему. Він займає введення, один байт за часом, і розбиває біти на окремі вхідні елементи. Виведення зшиває значення вихідних елементів назад разом у байти.

Розберемо це:

*є вихідним сигналом, він надсилатиме справжнє значення для всіх сусідніх елементів. 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

Безголовки:

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це не a 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 ​​Лабіринт натискає 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кінця Чака, який дасть або ?(що є дійсною командою), або @який є неоперативним.

,зчитує вхідний символ у першу клітинку Чака (позначена символом _). Ми хочемо зменшити це значення до 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корпусу.

Побітовий циклічний тег , 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починає цикл, який працює, поки значення, розташоване на вершині стека, є truthy, з тілом ■. ■друкує верхній елемент стека, не вискакуючи. Петля неявно закривається в EOF.

При введенні 0циклу цикл ніколи не виконується (оскільки 0це фальси), і програма закінчується на 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команди. Введіть ціле число в стек.
\, переспрямовує вказівник інструкції вниз через оп.
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