var QUESTION_ID=82938,OVERRIDE_USER=48934;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+(?:\.\d+)?)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="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><div id="language-list"> <h2>Winners 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><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>
Ответы:
Домино , 122 000 байт или 72 тайла
Количество байтов - это размер сохраненного файла, который есть
0.122 MB
.Вычисление Domino было вдохновением. Я проверил все это вплоть до симметрии (и даже дальше!) В виртуальной реальности Steam-игре под названием Tabletop Simulator .
подробности
True
или1False
или0100%
ворота
644343151132171376761615TL; DR
Я ждала / хотела бросить вызов домино, и когда я увидела это, я не смогла пройти мимо. Единственная проблема заключалась в том, что, очевидно, никто больше не владеет домино! Так что в конце концов я сдался и купил Дважды двенадцать . Этот набор имеет 91 плитку, что дало мне идею иметь «вызов функции» / старт домино вместо обычного (длительного) метода «временной задержки». Кредит на поворот на 90 градусов принадлежит каналу dominoesdouble07 .
После построения их с физическим домино, было исключено на мета , что действительные решения должны быть цифровыми. Поэтому я воссоздал эти ворота в Tabletop Simulator . К сожалению, TS и реальность не согласуются с физикой домино. Это потребовало от меня добавления 11 домино, но я также сэкономил 8. В целом, виртуальные домино примерно в 150 раз эффективнее в плане сборки и тестирования ( Ctrl+ Z).
Обновить
xor xnor nand
xnor
иxor
xor
иxnor
). Для блокировки на столешнице требуется только 1 домино вместо 2.источник
Гексагония , 89 байт
Спасибо FryAmTheEggman за необходимое вдохновение для решения XOR.
Все программы используют
0
для false и1
для true.Попробуйте онлайн! Это не набор тестов, вам придется копировать в разные программы и вводить данные самостоятельно.
Вышеупомянутое решение находится в пределах 2 байтов оптимальности (я полагаю, если мы не ослабим интерпретацию правдивости / ложности). Я пусть перебор баллотироваться около двух дней по всем программам , которые вписываются в боковой длину 2, то есть до 7 байт (не совсем все программы - я сделал несколько предположений о то , что каждых действительных потребностях программы и что нет действительная программа могла бы иметь). Поиском были найдены решения для 15 из 16 возможных ворот - и зачастую гораздо больше, чем один. Вы можете найти список всех альтернативных решений в этой папке, где я также сгруппировал их по эквивалентному поведению. Те, что я показываю выше, я выбрал, потому что это либо самое простое, либо самое интересное решение, и я добавлю их объяснения завтра.
Что касается 16-го шлюза: XOR - единственный вентиль, который, очевидно, не может быть реализован в 7 байтах. К сожалению, поиск по более крупным программам невозможен с кодом, который у меня есть в настоящее время. Так что XOR нужно было писать от руки. Самая короткая, которую я нашел до сих пор, - это вышеуказанная 10-байтовая программа, основанная на неудачной (но очень близкой) попытке FryAmTheEggman. Возможно, что существует 8-байтовое или 9-байтовое решение, но, кроме этого, все решения действительно должны быть оптимальными.
Пояснения
Предупреждение: стена текста. На случай, если кому-то интересно, как на самом деле работают эти сильно сжатые программы Hexagony, я привел объяснения каждой из них ниже. Я попытался выбрать простейшее решение для каждого шлюза в тех случаях, когда существует более одной оптимальной программы, чтобы объяснения были достаточно краткими. Тем не менее, некоторые из них все еще поражают воображение, поэтому я подумал, что они заслуживают немного большей проработки.
0000
: ЛожьЯ не думаю, что нам понадобится диаграмма для этого:
Поскольку вся сетка памяти инициализируется нулями,
!
просто печатает ноль и@
завершает программу.Это также единственное 2-байтовое решение.
0001
: А такжеЭто в основном реализует короткое замыкание . Серая диаграмма ниже показывает начало программы, где читается первый ввод,
?
а указатель инструкций (IP) оборачивается в левый угол, где его|
отражает зеркало. Теперь угол действует как условный, так что есть два разных пути выполнения в зависимости от значения первого ввода. Красная диаграмма показывает поток управления дляA = 0
и зеленая диаграмма дляA = 1
:Как вы можете видеть, когда
A
есть0
, тогда мы просто распечатываем его и завершаем (помните, что все.
они не используются). Но когдаA
есть1
, то IP снова пересекает первый ряд, читаяB
и печатая его.Всего существует шестнадцать 5-байтовых решений для этих ворот. Четырнадцать из них, по сути, такие же, как и выше, либо используют
>
вместо,|
либо заменяют.
команду, которая фактически не выполняет никаких действий, либо ставят?
во вторую позицию:И тогда есть два других решения (которые эквивалентны друг другу). Они также реализуют ту же логику короткого замыкания, но пути выполнения немного сумасшедшие (и оставлены в качестве упражнения для читателя):
0010
: А а не БЭто также реализует форму короткого замыкания, но из-за использования
#
потока управления намного сложнее.#
является условным IP-коммутатором. Hexagony фактически поставляется с шестью IP - адресов , помеченных0
к5
, которые начинаются в шести углах сетки, указывая вдоль их по часовой стрелке края (и программа всегда начинается с IP0
). Когда#
встречается, текущее значение берется по модулю6
, и поток управления продолжается с соответствующим IP. Я не уверен, какой приступ безумия заставил меня добавить эту функцию, но она, безусловно, допускает некоторые удивительные программы (вроде этой)Мы будем различать три случая. Когда
A = 0
, программа довольно проста, потому что значение всегда0
когда#
встречается так, что IP-переключение не происходит:#
ничего не делает,?
читаетA
(то есть тоже ничего не делает),#
все еще ничего не делает,!
печатает0
,)
увеличивает его (это важно, иначе IP не будет переходить на третью строку),@
завершает программу. Достаточно просто. Теперь давайте рассмотрим случай(A, B) = (1, 0)
:Красный путь все еще соответствует IP
0
, и я добавил зеленый путь для IP1
. Мы видим, что после?
чтенияA
(на1
этот раз)#
переключается на IP, который начинается в верхнем правом углу. Это означает, что?
можете читатьB
(0
). Теперь)
увеличивает это значение до1
такого, что#
в левом верхнем углу ничего не происходит, и мы остаемся с IP1
. В!
печатает1
и IP обтекает левую диагональ.#
по-прежнему ничего не делает и@
завершает программу.Наконец, действительно странный случай, когда оба входа
1
:На этот раз второй вход также
1
и)
увеличивает его до2
. Это означает, что#
в левом верхнем углу другой IP-переключатель переключается на IP2
, обозначенный синим цветом. На этом пути мы сначала увеличиваем его до3
(хотя это не имеет значения), а затем передаем?
третий раз. Так как мы теперь нажали EOF (т.е. ввод исчерпан),?
возвращает0
,!
печатает это и@
завершает программу.Примечательно, что это единственное 6-байтовое решение для этих ворот.
0011
: AЭто достаточно просто, и нам не понадобится диаграмма:
?
читаетA
,!
печатает,@
завершает работу.Это единственное 3-байтовое решение для этих ворот. (В принципе, это также было бы возможно сделать
,;@
, но поиск не включал;
, потому что я не думаю, что он когда-либо сможет сэкономить байты!
для этой задачи.)0100
: B, а не AЭтот намного проще, чем его "брат"
0010
. Поток управления фактически такой же, как мы видели выше для0001
(А). ЕслиA = 0
, то IP пересекает нижнюю строку, считываяB
и распечатывая ее перед завершением. ЕслиA = 1
затем IP снова пересекает первую строку, также считываяB
, но+
добавляет два неиспользуемых края памяти, все, что он делает, - сбрасывает текущее значение0
, чтобы!
всегда печатать0
.Существует довольно много 6-байтовых альтернатив этому (всего 42). Во-первых, существует масса решений, эквивалентных вышеперечисленным. Мы снова можем свободно выбирать между
|
и>
и+
можем быть заменены любой другой командой, которая дает нам пустое ребро:Кроме того, мы также можем использовать
]
вместо?
.]
переходит к следующему IP (т.е. выбирает IP1
), так что вместо этого эта ветвь использует?
в правом верхнем углу. Это дает еще 18 решений:И затем есть шесть других решений, которые все работают по-разному с различными уровнями сумасшествия:
0101
: BWoohoo, еще один простой: читать
A
, читатьB
, печататьB
, прекратить. Хотя на самом деле есть альтернативы этому. ПосколькуA
это только один символ, мы также можем прочитать его,
:И есть также возможность использовать одно
?
и использовать зеркало, чтобы пройти через него дважды:0110
: XorКак я уже говорил выше, это были единственные ворота, которые не вписывались бы в длину стороны 2, так что это рукописное решение от FryAmTheEggman и меня, и есть большая вероятность, что оно не оптимально. Есть два случая, чтобы различать. Если
A = 0
поток управления довольно прост (потому что в этом случае нам нужно только напечататьB
):Мы начинаем по красной дорожке.
?
читаетA
,<
это ветвь, которая отклоняет ноль слева. IP переносится вниз, затем_
- другое зеркало, а когда IP попадает в угол, он переносится в верхний левый угол и продолжается по синему пути.?
читаетB
,!
печатает это. Теперь(
уменьшает это. Это важно, потому что это гарантирует, что значение не положительное (оно0
или-1
сейчас). Это заставляет IP переноситься в правый угол, где@
завершается программа.Когда
A = 1
все становится немного сложнее. В этом случае мы хотим напечататьnot B
, что само по себе не так уж сложно, но путь исполнения немного триповый.На этот раз
<
IP отклоняет право, а затем следующий<
просто действует как зеркало. Таким образом, IP пересекает тот же путь в обратном направлении, читаяB
при?
повторном обнаружении IP переходит в правый угол и продолжается по зеленой дорожке. Она следующие встречи ,(~
которые являются «декремент, умножить на -1», которые свопы0
и1
поэтому рассчитываетnot B
.\
это просто зеркало и!
печатает желаемый результат. Затем?
пытается вернуть другое число, но возвращает ноль. IP теперь продолжается в левом нижнем углу на синем пути.(
уменьшает,<
отражает,(
снова уменьшается, так что текущее значение является отрицательным, когда IP достигает угла. Он перемещается по нижней правой диагонали, а затем, наконец, нажимает,@
чтобы завершить программу.0111
: Или жеБолее короткое замыкание.
A = 0
Случай (красный контур) немного запутанным здесь. IP отклоняется влево, переносится в нижний левый угол, сразу же отражается<
и возвращается?
к чтениюB
. Затем он заворачивает к rigt углу, печатаетB
с!
и заканчивается.A = 1
Случай (зеленый путь) немного проще.<
Филиал отклоняет IP право, поэтому мы просто напечатать!
, завернуть обратно в левом верхнем углу, и заканчиваются в@
.Есть только одно 5-байтовое решение:
Он работает по сути одинаково, но фактические пути выполнения весьма различны и используют угол для ветвления вместо a
<
.1000
: НиЭто может быть моя любимая программа, найденная в этом поиске. Самое классное, что эта реализация на
nor
самом деле работает до 5 входов. Мне придется немного углубиться в детали модели памяти, чтобы объяснить это. Таким образом, для быстрого освежения модель памяти Hexagony представляет собой отдельную шестиугольную сетку, где каждое ребро содержит целочисленное значение (изначально все ноль). Есть указатель памяти (MP), который указывает ребро и направление вдоль этого ребра (так, что есть два соседних ребра перед и за текущим ребром, с значимыми левыми и правыми соседями). Вот диаграмма ребер, которые мы будем использовать, начиная с MP, как показано красным:Давайте сначала рассмотрим случай, когда оба входа
0
:Мы начинаем с серого пути, который просто увеличивает ребро A до
1
так, чтобы#
переключиться на IP,1
который является синим путем, начиная с правого верхнего угла.\
ничего не делает там и?
читает вход. Мы переносим в верхний левый угол, где)
увеличивается этот вход. Теперь, пока ввод равен нулю, это приведет к1
, так что#
ничего не делает. Затем{
перемещает MP влево, то есть на первой итерации от к B . Так как у этого края все еще есть свой начальный ноль, IP возвращается в верхний правый угол и на новый край памяти. Так что этот цикл будет продолжаться до тех пор, пока он читает нули, перемещая MP вокруг шестиугольника от B?
от C до D и так далее. Неважно,?
возвращает ли ноль, потому что это был вход или потому что это был EOF.После шести итераций через эту петлю,
{
возвращается к . На этот раз ребро уже содержит значение с самой первой итерации, поэтому IP оборачивается в левый угол и вместо этого продолжает зеленый путь. просто печатает это и завершает программу.1
!
1
@
А что если какой-либо из входов есть
1
?Затем
?
читает это1
в какой-то момент и)
увеличивает его до2
. Это означает,#
что теперь снова переключатся IP-адреса, и мы продолжим в правом углу по красной дорожке.?
читает другой ввод (если он есть), который на самом деле не имеет значения, и{
перемещается на один край дальше. Это должен быть неиспользуемый фронт, следовательно, он работает до 5 входов. IP переносится в верхний правый угол, где он сразу отражается, и переносится в левый угол.!
печатает0
на неиспользованном крае и#
переключается обратно на IP0
. Этот IP-адрес все еще находился на#
юго-западе (серый путь), поэтому он сразу же нажимает на@
и завершает программу.Всего существует семь 7-байтовых решений для этих ворот. 5 из них работают так же, как это, и просто используют другие команды для перемещения к неиспользуемому краю (и могут ходить по другому шестиугольнику или в другом направлении):
И есть еще один класс решений, который работает только с двумя входами, но пути выполнения которых на самом деле еще более беспорядочные:
1001
: РавенствоЭто также делает очень умным использование условного выбора IP. Нам нужно еще раз различать
A = 0
иA = 1
. В первом случае мы хотим напечататьnot B
, во втором мы хотим напечататьB
. ИбоA = 0
мы также различаем два случаяB
. Давайте начнем сA = B = 0
:Мы начинаем на сером пути.
(~
может быть проигнорировано, IP переносится в левый угол (все еще на сером пути) и читаетA
с?
.(
уменьшает это, так что мы получаем-1
и IP обернуть в левый нижний угол. Теперь, как я уже говорил ранее,#
принимает значение по модулю,6
прежде чем выбрать IP, так что значение-1
фактически получает IP5
, который начинается в левом углу на красном пути.?
читаетB
,(
уменьшает это так, чтобы мы оставались на IP,5
когда мы#
снова нажмем.~
отрицает-1
так, что IP переносится в правый нижний угол, печатает1
и завершается.Теперь , если
B
это1
вместо того, чтобы , текущее значение будет ,0
когда мы попали#
во второй раз, поэтому мы переходим обратно в IP0
( в настоящее время на зеленом пути). Это ударяет?
в третий раз, уступает0
,!
печатает это и@
заканчивается.Наконец, случай, когда
A = 1
. На этот раз текущее значение уже равно нулю, когда мы нажимаем#
в первый раз, так что это никогда не переключается на IP5
в первую очередь. Мы просто продолжаем немедленно на зеленой тропе.?
теперь не просто дает ноль, а возвращаетB
вместо этого.!
печатает его и@
завершает снова.Всего есть три 7-байтовых решения для этих ворот. Два других работают очень по-разному (даже друг от друга) и используют еще более странно
#
. В частности, они читают одно или несколько значений с помощью,
(чтение кода символа вместо целого числа), а затем используют это значение по модулю 6, чтобы выбрать IP. Это довольно орешки.1010
: Не BЭто довольно просто. Путь выполнения - это горизонтальная ветвь, о которой мы уже знали
and
ранее.??
читает,A
а потом сразуB
. После отражения в|
и разветвления, дляB = 0
мы выполним нижнюю ветвь, где)
увеличивает значение, на1
которое затем печатается!
. В верхней ветви (еслиB = 1
)?
просто сбрасывается край, на0
который затем также печатается!
.Для этих ворот есть восемь 6-байтовых программ. Четыре из них в значительной степени одинаковы, используя либо
>
вместо,|
либо1
вместо)
(или оба):Два используют один,
?
который используется дважды из-за зеркала. Отрицание тогда происходит, как мы сделалиxor
с или(~
или~)
.И, наконец, два решения используют условный IP-коммутатор, потому что зачем использовать простой способ, если извилистый также работает:
1011
: B подразумевает AЭто использует довольно сложную IP-коммутацию. На
A = 1
этот раз я начну со случая, потому что это проще:Мы начинаем с серого пути, который читает
A
с,?
а затем нажимает на#
. ТакA
как1
это переключается на IP1
(зеленый путь).!
Сразу печатает того, IP - обертывания в левом верхнем углу, читаетB
(излишне) и завершает работу .Когда
A = 0
все становится немного интереснее. Сначала давайте рассмотримA = B = 0
:На этот раз,
#
ничего не делает, и мы остаемся на IP0
(красный путь с этого момента).?
читаетB
и1
превращает его в1
. После переноса в верхний левый угол мы#
снова нажимаем, и в конце концов оказываемся на зеленом пути, и печатаем,1
как и прежде, перед завершением.Наконец, вот
(A, B) = (0, 1)
ложный случай:Обратите внимание, что я удалил начальный серый путь для ясности, но программа начинается так же, и мы в конечном итоге на красный путь, как и раньше. Так что на этот раз второй
?
возвращается1
. Теперь мы сталкиваемся с1
. На этом этапе важно понять, что на самом деле делают цифры в гексагонии (пока мы использовали их только в нулях): когда встречается цифра, текущее значение умножается на 10, а затем цифра добавляется. Это обычно используется для записи десятичных чисел дословно в исходный код, но это означает, чтоB = 1
на самом деле отображается в значение11
. Поэтому, когда мы нажимаем#
, это принимается по модулю,6
чтобы дать,5
и, следовательно, мы переключаемся на IP5
(а не1
как раньше) и продолжаем идти по синему пути. Удары?
третий раз возвращает ноль, поэтому!
печатает, что, а после еще двух?
, IP оборачивается внизу справа, где программа завершается.Для этого есть четыре 7-байтовых решения, и все они работают по-разному:
1100
: Не АПросто простой линейный один: чтение
A
с?
, свести на нет с(~
, печатать!
, оканчиваются@
.Есть одно альтернативное решение, и
~)
вместо этого оно отрицает :1101
: A подразумевает BЭто намного проще, чем противоположное значение, о котором мы только что говорили. Это снова одна из тех горизонтальных программ ветвления, например, для
and
. ЕслиA
есть0
, он просто увеличивается до1
нижней ветви и печатается. В противном случае верхняя ветвь выполняется снова, где?
читаетB
и затем!
печатает это вместо.Там в тонну альтернатив здесь (66 решений в целом), в основном за счет свободного выбора эффективных нет-OPS. Для начала мы можем варьировать вышеупомянутое решение теми же способами, что
and
и мы, и мы также можем выбирать между)
и1
:И тогда есть другой вариант , используя условный выбор IP, где первая команда может быть выбрана почти произвольно, и есть также выбор между
)
и1
для некоторых из этих вариантов:1110
: NandПоследний сложный. Если вы все еще читаете, вы почти сделали это. :) Давайте посмотрим
A = 0
сначала:?
читает,A
а затем мы ударили$
. Это команда перехода (например, Befunge#
), которая пропускает следующую инструкцию, чтобы мы не заканчивались на@
. Вместо этого IP продолжает в#
. Однако , так какA
есть0
, это ничего не делать.)
увеличивает его1
так, чтобы IP продолжался по нижнему пути, где1
печатается. В<
отклоняет IP - вправо , где он заворачивает к левому углу , и программа завершается.Далее, когда на входе
(A, B) = (1, 0)
мы получаем эту ситуацию:Это по сути то же самое , как и раньше , за исключением , что на
#
мы переходим к IP1
(зеленый путь), но так какB
это0
мы вернуться к IP ,0
когда мы попали#
во второй раз (теперь синий путь), где он печатает ,1
как и раньше.Наконец,
A = B = 1
дело:На этот раз, когда мы
#
во второй раз, текущее значение все еще1
так, чтобы мы не изменили IP снова.<
Отражает это и в третий раз мы попали ,?
мы получаем ноль. Следовательно, IP оборачивается внизу слева, где!
печатается ноль, и программа заканчивается.Для этого существует девять 7-байтовых решений. Первая альтернатива просто использует
1
вместо)
:Тогда есть два решения, которые помогут вам оценить количество IP-коммутаций:
Это на самом деле поразило меня: интересная часть заключается в том, что IP-переключение можно использовать в качестве условного отсрочки. Языковые правила переключения IP таковы, что текущий IP делает еще один шаг, прежде чем произойдет переключение. Если этот шаг проходит через угол, то текущее значение решает, на какой ветви будет продолжаться IP, если мы когда-нибудь переключимся на него. Именно это происходит, когда ввод
A = B = 1
. Хотя все это согласуется с тем, как я проектировал язык, я никогда не знал об этом значении спецификации, поэтому приятно, когда мой язык учит меня новым трюкам: D.Тогда есть третье решение, степень IP-переключения которого еще хуже (хотя он не использует этот отложенный условный эффект):
А потом еще один:
И затем есть эти четыре эквивалентных решения, которые используют некоторую безусловную IP-коммутацию и вместо этого реализуют всю логику через ответвления и углы:
1111
: ПравдаВы заработали себе что-то простое для конца: установите преимущество
1
, напечатайте!
, завершите с@
. :)Конечно, есть одна альтернатива:
Как обычно, все блок-схемы управления созданы с помощью HexagonyColorer Тимви и диаграммы памяти с его EsotericIDE .
источник
APL,
222018 байтИстинные и ложные записи являются полными программами, а остальные 14 являются функциями. (Спасибо Адаму.)
Попробуй это здесь.
источник
0
и1
.Шахматист / посредственный шахматист в эндшпиле, 70 штук
Вдохновленный этим ответом на домино, я решил, что другая игра должна иметь эту честь.
Обратите внимание, что я взял несколько правил того, как движутся фигуры. Поскольку мне не хочется изучать оптимальные ходы для каждой ситуации, правила для хода белых просты: не поддавайтесь проверке, захватите фигуру с самым высоким рейтингом, которую он может сделать в этот ход, потеряв при этом как можно меньше материала, и остановите пешку. от продвижения в таком порядке приоритета. Если есть два пространства, в которые он может перейти, с одинаковой благоприятностью, он может перейти в любое из них (следовательно, в них, если он может перейти в более чем один квадрат, они одного цвета). Обратите внимание, что белые будут захватывать что-то, даже если они захвачены, если фигура, которую они атакуют, имеет более высокую ценность, чем потерянная. Значения здесь:
pawn<knight=bishop<rook<queen
Вход - наличие грача или нет. Обратите внимание, что ладьи помечаются именами A и B, только когда это имеет значение: если ворота ведут себя одинаково, когда ладьи переключаются, они не помечаются.
Вывод цвета квадратного белого короля заканчивается: белый = 1, черный = 0
Перед изображениями я хочу извиниться за плохие изображения. Я не очень хорошо держу камеру устойчиво.
Неверно, 4:
И, 4:
A, а не B, 5 (я думаю, что могу уменьшить это до трех, но сейчас у меня нет доски):
А, 4:
Не A и B, 5 (я думаю, я могу уменьшить это до трех, но сейчас у меня нет доски):
Б, 4:
Xor, 5 (я знаю, как сделать это 4, но у меня сейчас нет доски):
Или 4:
Ни 4:
Xnor, 5 (я знаю, как сделать это 4, но у меня сейчас нет доски):
Не B, 4:
B подразумевает A, 5 (я думаю, я могу уменьшить это до трех, но сейчас у меня нет доски):
Не А, 4:
A подразумевает B, 5 (я думаю, я могу уменьшить это до трех, но сейчас у меня нет доски):
Нанд, 4:
Правда, 4:
источник
Желе , 19 байт
Попробуйте онлайн!
источник
¤
и¬
2 байта, а не 1.0 0 1 0 > 1 byte Greater than.
не потерпит ли это неудачу, если второй вход будет отрицательным?Логические ворота NAND - 31 вентиль
Как создатель оригинальной серии вопросов о воротах NAND , я не мог упустить возможность использовать эти ворота для решения другой проблемы логических ворот.
На каждой из этих диаграмм верхний вход - А, а нижний - Б.
источник
Побитовая циклическая метка , 118 бит = 14,75 байт
Побитовая циклическая метка, пожалуй, самый простой Turing-Complete язык, когда-либо разработанный. Существует программная лента и лента данных, состоящая из списка битов. Программная лента интерпретируется циклически, пока лента данных не станет пустой, следующим образом:
0
: удалить первый бит с ленты данных.1x
: если первый бит ленты данных равен 1, добавьте этот битx
на ленту данных.Мы инициализируем ленту данных с 1, за которым следуют два входных бита (1 необходим, потому что невозможно создать 1, если лента с данными полностью состоит из 0), и мы используем последний бит удаленных данных в качестве выхода шлюза ,
false
):001
and
):1001001
A and not B
):0110100
A
):1001
not A and B
):0100
B
):0
xor
):0110110010
or
):0110
nor
):1101001000
xnor
):110101001100
not B
):1100100
B implies A
):110101101000
not A
):11010000
A implies B
):11010011001
nand
):10110100100010
true
):1100
источник
1
поfalse
необходимости?0
к ленте, чтобы она могла быть удалена последней.Python 2, 137 байт
Принимает данные как
min(True,False)
(или какmin(1,0)
). Получает большое преимущество от результатов, требующих только правильного значения Truthy-Falsey. По возможности, используется встроенный, чтобы избежать дорогостоящихlambda
. Я использовал код для поиска встроенных модулей, которые работают.Мой любимый
{0:1}.get
, о котором я думал вручную. Словарь{0:1}
сопоставляет ключ0
со значением1
. Егоget
метод принимает ключ и значение по умолчанию, выводя значение, соответствующее ключу, или значение по умолчанию, если такого ключа нет. Таким образом, единственный способ вывести a0
- это{0:1}.get(1,0)
с отсутствующим ключом1
и значением по умолчанию0
. Можно найти другие варианты с разными словарями, но только этот был самым коротким.источник
__lt__
или__eq__
? Это еще больше уменьшит количество байтов:int.__gt__
вместоlambda a,b:b<1
,int.__eq__
вместоlambda a,b:a==b
и так далееint
сравнения разгрузки сcmp
. Я не пробовал это для Python 3.not
для0001
,False
- ideonenot
это не соответствует требованиям функции, потому что вы не можете сделатьf=not;f(3,4)
. Строкаnot
работает, потому что предполагаемые аргументы функции выглядят как кортеж, точно так же3+
, как3+(4)
если бы они3+
не работали4
как входные данные.Go (игра), 33 камня, 73 перекрестка
Если домино и шахматы приемлемы, то это. На полной доске размером 19х19 Го не может быть слишком много гольфа. Поэтому я использовал маленькие прямоугольные доски. Входные данные - присутствуют ли камни, отмеченные 1 и 2. Вывод - победит ли черный. Используется оценка по площади, 0,5 коми, ситуационная суперко, без самоубийств. Все черное, чтобы играть. Некоторым дается несколько решений.
Белые победы (2, 1х5):
1 и 2 (3, 2х3):
1 а не 2 (2, 1х5):
1 (2, 1x5):
Не 1 и 2 (2, 1х5):
2 (2, 1x5):
1 xor 2 (2, 2x3):
1 или 2 (2, 1x5):
1 или 2 (2, 1x4):
1 = 2 (2, 1x7):
Не 2 (2, 1х3):
1 или нет 2 (2, 1x4):
Не 1 (2, 1x3)
Не 1 или 2 (2, 1x4):
1 и 2 (2, 1x3):
Черные победы (2, 1x3):
Эта страница мне немного помогла: http://www.mathpuzzle.com/go.html
Может быть, кто-то мог бы найти решение 2 камня для 1 и 2 на доске 1x9 ...
источник
Javascript ES6, 124 байта
Я серьезно ненавижу лямбды прямо сейчас.
источник
a=>b=>0
чтобыa=>0
и сказать , что грамматика называть это является(a=>0)(a,b)
только для тех 4 записей.Math.min
вместоa=>b=>a&b
.Math.max
вместоa=>b=>a|b
.Math.pow
вместоa=>b=>a>=b
.parseInt
вместоa=>b=>a>b
.!NaN
=>true
,!!NaN
=>false
Сетчатка ,
6239 байт23 байта благодаря @MartinEnder !
Принимает вход как
PQ
.Выводит целое число между
0
до3
.0
ложь, другие правдивы.объяснение
Все они просто регулярные выражения .
Например,
01|10
просто соответствует01
или10
.В
0000
,2
никогда не будет на входе, поэтому он никогда не совпадает.В
1111
, это соответствует пустой строке, которая есть4
.источник
^1|0$
должен соответствовать только 1 символьной строке. Что тут происходит?1
в начале ввода] ИЛИ [0
в конце ввода]. Мне^1|0$
, труднее читать, чем1.|.0
. Кажется, что в целомСтека кошек , 67 + 64 = 131 байт
Обратите внимание, что +64 от применения
-nm
флагов к каждой программе.-n
указывает на числовой ввод-вывод и-m
отражает исходный код по последнему символу - эти флаги технически нужны не для всех представлений, но для последовательности и простоты я все равно их оцениваю.()
в Stack Cats проверяет, является ли элемент положительным или неположительным (т. е. 0 или отрицательным), поэтому мы используем его для истинности / ложности соответственно. Второй столбец только для интереса, и в нем перечислены лучшие ворота с0
/1
s в качестве выходных данных (с общим счетом 90).Ввод разделенных разделителями бит через STDIN. Попробуйте онлайн!
Stack Cats - это обратимый эзотерический язык, в котором программы обладают отражающей симметрией. Учитывая фрагмент
f
(например>[[(!-)/
), зеркальное изображение (например\(-!)]]<
) вычисляет обратноеf^-1
. Таким образом, программы четной длины ничего не делают (или застревают в бесконечном цикле), и единственные нетривиальные программы имеют нечетную длину, вычисляяf g f^-1
гдеg
оператор центра.Поскольку половина исходного кода всегда является избыточной, ее можно исключить, а выполнение кода с
-m
флагом указывает, что исходный код должен быть зеркально отображен поверх последнего символа для получения фактического исходного кода. Например, программа*<X
на самом деле*<X>*
, которая является симметричной.Гольф в Stack Cats крайне не интуитивен, поэтому вышеперечисленные программы нужно было искать грубой силой. Большинство из них удивительно сложны, но я объясню несколько и добавлю к этому ответу, когда у меня будет время. На данный момент некоторые объяснения и альтернативные решения для версий
0
/1
можно найти здесь в репозитории Github .источник
Note that the +64 is from applying the -nm flags to each program.
3 * 16 = 48 или 2 * 16 = 32, в любом случае 64 - это хайHaskell,
787675 байт_#_=2<1
&&
>
pure
<
_#b=b
/=
||
(not.).max
==
_#b=not b
>=
a#_=not a
<=
(not.).min
_#_=1<2
Редактировать: -1 байт благодаря @cole.
источник
_#_
это не стандартный оператор!" И тогда я понял ... Молодец.pure
pure
был введен вPrelude
далеком 2015 году, поэтому он был доступен во время этого испытания.Брахилог ,
3634 байтаЭто ожидает
0
как ложную ценность и1
как истинную ценность. Возвращаетtrue
илиfalse
. р естьInput
и д естьOutput
.источник
Input
иOutput
по соглашению, но вы можете установить значения для обоих или вернуть значения из обоих.Пролог,
147145 байтПолучил 2 байта благодаря @SQB
Запросить
x(P,Q).
сx
соответствующей буквы иP
иQ
установить либо 0 или 1.Возвращает
true
илиfalse
.Пример SWISH, включая тесты - введите
runTest.
для запуска.источник
a(2,2).
ложь?a(a,a).
(или любая другая буква) тоже работает иa
не является приемлемым источником правдивости, так что это хорошо. Спасибо за предложение.NTFJ, 86 байт
Попробуй это здесь! Но сначала прочтите ниже.
Ввод неявно в стеке. Результат помещен в стек. Добавьте 16 байтов (по одному
*
в конец каждого), если хотите,0x00
или0x01
выведите 0 и 1. Добавьте еще 160 байтов, если хотите0
или1
напечатали. (Поставьте~~##~~~#{@
перед каждым*
.)Единственный двоичный оператор NTFJ - это NAND, поэтому каждый из них записан в форме NAND.
Давайте пройдемся по каждому из них.
0: ложь
~
представляет ложный бит. Достаточно просто. Так как ввод неявен внизу стека, он остается вверху.1: p и q
NTFJ работает в стеке.
:
это команда для дубликата. Соблюдайте этоp and q
≡not (p nand q)
и этоnot q = q nand q
.(Обратите внимание, тогда
:|
можно сказать, что отрицание и|:|
можно сказать, что соединение )2: р а не д
Заметьте, что это просто отрицание
:|
и соединение|:|
.3: р
$
выталкивает предмет из стека. Так что да.4: не р и д
Это то же самое, что и 2, кроме
#{
как в начале.#
нажимает 1 (истинный бит) и{
поворачивает стек влево один раз. Достаточно просто.5: q
Поверните налево один раз, опустите.
6: XOR
Заметим:
Тем не менее, нет никакого способа полностью продублировать стек. Таким образом, мы будем иметь , чтобы привести каждого из
p
,q
в верхней и дублировать его.И, таким образом, у нас есть xor.
7: p или q
Отрицание сверху, доведение снизу вверх, отрицание этого и nand их вместе. В основном
p or q = (not p) nand (not q)
.8: не р и не д
Это просто отрицание 7. Легко.
9: экв
Это просто xnor или не xor. Просто снова.
10: не q
Отрицание 5.
11: р или нет д
Отрицание р, нанд.
(not p) nand q = not ((not p) and q) = p or (not q) (by De Morgan's laws)
,12: не р
Бросай, останавливайся и отрицай.
13: не р или д
Законы де Моргана, чтобы спасти день, снова! Тот же процесс, что и 11, только отрицание
q
вместоp
.14: не р или не д
Это просто мимик Нанд.
15: правда
#
это правда.источник
:|
?Майнкрафт, 89 блоков
На всех следующих фотографиях синие блоки предназначены для входа A, а оранжевые - для входа B
16. ВЕРНЫЕ ворота - 1 блок
15. NAND ворота - 1x2x3 = 6 блоков
14. A => B - 1x2x3 = 6 блоков
13. НЕ А - 2 блока
12. B => A - 1x2x3 = 6 блоков
11. НЕ Б - 2 блока
10. XNOR - 1x3x4 = 12 блоков
9. NOR - 1x2x3 = 6 блоков
8. ИЛИ - 1 блок
7. XOR - 1x3x4 = 12 блоков
6. Б - 1 блок
5.! A & B - 1x2x5 = 10 блоков
4. А - 1 блоков
3. A &! B - 1x2x5 = 10 блоков
2. И - 2х2х3 = 12 блоков
1. ЛОЖЬ - 1 блок
источник
Mathematica, 67 байт
Каждый из них оценивает функцию, поэтому вы можете использовать их как
Ах, если бы в Mathematica только целые числа были истинными / ложными, эти четыре более длинные могли бы быть значительно сокращены.
источник
MATL,
3423 байтаЯ надеюсь, что я получил заказ в порядке! Ноль - это ложь, ненулевое - это правда. Каждая функция принимает два неявных входа (хотя может игнорировать некоторые входные данные). Первый вход A, а второй B. Вы можете ввести
0
/1
для true / false, илиT
/F
.Вот пример TryItOnline для контрольного примера 3.
Сэкономили 4 байта, используя
*
forand
, и еще 4, используя>
/<
вместо~wY&
/w~Y&
после того, как я увидел ответ Денниса!источник
-
постоянный ток, 37 байт
dc
(«настольный калькулятор») - это стандартная команда unix, основанный на стеке постфиксный калькулятор. В нем отсутствуют битовые операции, а операторы сравнения могут использоваться только для выполнения макросов (что не стоит байтов). Целочисленное деление восполняет некоторые из этого.Эти сценарии ожидают
0
и1
значения в стеке, и оставляют результат в стеке.источник
Лабиринт , 85 байт
Спасибо Sp3000 за сохранение 2 байта.
Все это полные программы, которые читают два целых числа
0
или1
из STDIN (используя любой нецифровый разделитель) и печатают результат как0
или1
в STDOUT.Попробуйте онлайн! (Не тестовый набор, поэтому вам придется вручную пробовать разные программы и входы
Что касается объяснений, все они довольно просты. Все программы являются линейными, и используемые команды выполняют следующее:
Обратите внимание, что я использую
#
всегда используется для его объединения$
, то есть для вычисленияXOR 1
или, другими словами, для логического отрицания. Только в нескольких случаях я смог использовать~
вместо этого, потому что последующий&
отбрасывает все ненужные биты из результирующего-1
или-2
.источник
Машинный код IA-32, 63 байта
Hexdump кода, с разборкой:
Код длиннее, чем мог бы быть, потому что он использует стандартное соглашение о кодировании: вход в
ecx
иedx
, и вывод вal
. Это может быть выражено в C какКажется, что MS Visual Studio не понимает недокументированные
SALC
код операции, поэтому мне пришлось использовать его код, а не имя.Спасибо вам l4m2 за улучшение некоторых примеров кода!
источник
1110 8D4411FE LEA EAX, [ECX+EDX-2]
C 34 байта
Где n - это номер функции, которую нужно использовать, но я думаю, что в ней будет отказано, поэтому я предлагаю другую:
C 244 байта (используя память)
он использует двойной индексированный массив.
n[0][1]
является(A implies B)(0,1)
Далее 138 байт
Я только что узнал Форт. Я полагаю, что это совместимо с Ansi Forth, поскольку оно работает и на gforth.
Функция z создает новую функцию с указанным именем, затем помещает номер логического элемента из вершины стека в адрес новой функции. Он оставляет следующую (n + 1) функцию логического элемента в стеке для следующего объявления.
Вы можете проверить это:
и AB
(«.» печатает верхнюю часть стопки, «cr» - возвращение кариеса)
источник
C 268 байт
Макросы кажутся короче функций.
источник
Брайан и Чак , 183 байта
Спасибо Sp3000 за сохранение 4 байта.
Некоторые из программ содержат непечатаемый символ. В частности, каждый
\x01
должен быть заменен<SOH>
управляющим символом (0x01):Входные и выходные данные используют байтовые значения , поэтому на входе должны быть два байта 0x00 или 0x01 (без разделителя), и на выходе будет один такой байт. На самом деле это также наиболее разумное определение истинности / ложности для B & C, потому что единственная команда потока управления
?
считает нули ложными, а все остальное - правдивыми.Пояснения
Сначала быстрый B & C учебник для начинающих:
,
(входной байт), и только Чак может использовать команду.
(выходной байт).[]
цикле не существует. Вместо этого у вас есть единственный поток управления,?
который переключает управление на другой экземпляр, если текущее значение под головкой ленты отлично от нуля.>
и<
, есть{
и}
которые по существу эквивалентны фрагменты Brainfuck[<]
и[>]
, то есть, они двигают голову ленты к следующей нулевой позиции в этом направлении. Основное отличие заключается в том, что{
его также можно остановить на левом конце ленты, независимо от того, какое значение она имеет._
s в исходном коде заменяются нулевыми байтами (так как они очень полезны в нетривиальных программах, чтобы поймать{
и}
).Обратите внимание, что во всех программах лента Чака начинается с
#
. Это действительно может быть что угодно.?
работает так, что головка ленты перемещается на одну ячейку перед началом выполнения (так что само условие не выполняется, если оно оказывается действительной командой). Поэтому мы никогда не сможем использовать первую ячейку Чака для кода.Есть пять классов программ, которые я подробно объясню позже. Пока я перечисляю их здесь в порядке возрастания сложности.
0000
,1111
: Постоянные функцииЭто очень просто. Мы переключаемся на Чака безоговорочно. Чак перемещает головку ленты в неиспользуемую ячейку справа и либо печатает ее напрямую, либо увеличивает ее в первую очередь для печати
1
.0011
,0101
,1010
,1100
: Функции в зависимости от только один входВ зависимости от того, начинаем ли мы с
,
или,,
мы работаем сA
илиB
. Давайте посмотрим на первый пример0011
(т.е.A
). После прочтения значения мы используем его?
в качестве условия. ЕслиA = 1
, то это переключается на Чака, который перемещает головку ленты вправо и печатает буквально встроенный1
-байт. В противном случае контроль остается за Брайаном. Здесь 1-байт не работает. Затем мы хорошо увеличиваем вход,+
чтобы убедиться, что он ненулевой, а затем переключаемся на Чака с помощью?
. На этот раз>
перемещается в неиспользуемую ячейку справа, которая затем печатается как0
.Чтобы опровергнуть одно из значений, мы просто уменьшаем его
-
. Это превращается1
в0
и0
в-1
, что является ненулевым и, следовательно, правдивым, насколько?
это касается0001
,0010
,0100
,1000
: Бинарные функции с одним truthy результатЭто расширение предыдущей идеи для работы с двумя входами. Давайте посмотрим на пример
1000
(NOR). Мы (потенциально) читаем оба ввода с,?
. Если что-то из этого есть1
,?
переключается на Чака. Он перемещает головку ленты до конца}
(на пустую ячейку после кода Брайана), перемещает другую ячейку с>
(все еще ноль) и печатает ее с помощью.
.Тем не менее, если оба входа равны нулю, управление все равно остается за Брайаном.
>
затем перемещает головку ленты так}
, что эта команда не выполняется, когда мы переключаемся на Чака с помощью?
. Теперь все, что делает Чак, это>.
только перемещается на1
-клетку и печатает это.Мы можем легко получить другие три функции, отрицая один или оба входа, как требуется.
0111
,1011
,1101
,1110
: Бинарные функции с тремя truthy результатамиНезначительная модификация предыдущей идеи, чтобы свести на нет результат (например, распечатать,
0
когда мы прошли через Брайана и т. Д.1
). Давайте посмотрим на0111
(ИЛИ) в качестве примера. Обратите внимание, что встроенный1
-byte не используется, поэтому он все еще начинается с,?,?
. Если любой из этих входов -1
мы переключаемся на Чака, который перемещает головку ленты обратно в начало{
.>.
перемещает головку ленты на этот1
байт и печатает ее.Если оба входа равны нулю, мы останемся с Брайаном, переместим головку ленты,
{
чтобы пропустить ее, а затем переключимся на Чака. Когда он выполняет>.
это время, он перемещается в пустую ячейку после кода Брайана и печатает0
.Опять же, мы легко получаем другие функции, отрицая один или оба входа.
0110
,1001
: Двоичные функции с двумя достоверными результатамиЭтот немного сложнее. Предыдущие функции были достаточно простыми, потому что они могут быть замкнуты накоротко - значение первого входа может определять выход, а если нет, то мы смотрим на другой вход. Для этих двух функций нам всегда нужно смотреть на оба входа.
Основная идея состоит в том, чтобы использовать первый вход, чтобы решить, выбирать ли второй вход между
0
и1
или между1
и0
. Давайте возьмем0110
(XOR) в качестве примера:Посмотрим
A = 0
. В этом случае мы хотим вывестиB
как есть.,
читаетA
,?
ничего не делает.>
переходит на следующую (ненулевую) ячейку, что}
приводит нас к_
Чаку. Здесь мы читаемB
с,
и использовать?
снова. Если быB
было0
так же, мы все еще на Брайане.>
пропускает}
Чак и?
переключается так, чтобы>.
печатать0
встроенный в исходный код Брайана. ЕслиB
был1
с другой стороны, Чак делает выполните}
который движется в_
в коде Брайана уже, так что>.
затем печатает1
-байт вместо этого.Если
A = 1
, тогда мы сразу переключаемся на Чака, который будет казнить}+{>?
. Что он делает, так это перемещается к_
исходному коду Брайана, превращает его в a,1
а+
затем возвращается к началу{
и пропускает Брайана,?
перемещая одну ячейку вправо>
перед тем, как передать управление ему. На этот раз, после того, как Брайан РидаB
, еслиB = 0
, и Чак использует>.
ячейку рядом с Брайан?
будет1
вместо0
. Кроме того, когдаB = 1
Чак}
пропускает то, что раньше было пропуском, и перемещается полностью до конца ленты, так что>.
вместо этого печатается ноль. Таким образом, мы печатаемnot B
.Чтобы реализовать эквивалентность, мы просто отрицаем ее
A
перед использованием в качестве условия. Обратите внимание, что из-за этого нам также нужно добавить еще один>
в Чака, чтобы пропустить это-
и при возвращении к началу.источник
ClojureScript,
88 84 7674 байтаnil
иfalse
ложны, все остальные ценности правдивы. Булевы значения приводят к 0/1 для арифметики и неравенств. Функции могут принимать неверное количество аргументов.источник
0
обман?not not(0)
чтобыFalse
, который является falsey значение.#f
,f
,false
и т.д.) является ложный. Все остальные ценности правдивы в большинстве функциональных языков.Brainfuck ,
184178174 байтаВвод / вывод использует U + 0000 и U + 0001.
источник
0001
не могли бы вы просто сделать,[,>]<.
(учитывая переводчика, который позволяет вам идти слева от начальной ячейки)?Brain-Flak ,
418, 316 байтПопробуйте онлайн!
Пусть входные данные будут двумя верхними числами в стеке в начале программы (ноль - для ложного, один - для истины), а выходные данные - для верха стека в конце программы (ноль для ложного, в противном случае - для истины).
false, 4 байта (Предоставлено Leaky Nun )
(<>)
и 36 байтов
(({}{}[(())()])){{}{}(((<{}>)))}{}{}
А, а не В, 40 байт
((({}){}{}[(())()])){{}{}(((<{}>)))}{}{}
А, 6 байт
({}<>)
не А и В, 38 байт
((({}){}{}[(())])){{}{}(((<{}>)))}{}{}
B, 2 байта
{}
xor, 34 байта
(({}{}[(())])){{}{}(((<{}>)))}{}{}
или 6 байтов
({}{})
ни 34 байта
(({}{}<(())>)){{}{}(((<{}>)))}{}{}
xnor, 10 байт
({}{}[()])
не B, 34 байта
{}(({}<(())>)){{}{}(((<{}>)))}{}{}
B подразумевает A, 14 байтов
(({}){}{}[()])
не A, 34 байта
(({}<{}(())>)){{}{}(((<{}>)))}{}{}
A подразумевает B, 16 байтов
(({}){}{}[()()])
nand, 12 байт
({}{}[()()])
правда, 6 байтов
<>(())
объяснение
Поскольку большинство из них очень похожи, я не буду объяснять, как именно работает каждый из них. Я стараюсь изо всех сил, чтобы понять, как работают все шестнадцать.
Во-первых, это ворота, которые возвращают три одинаковых значения (т. Е. 2, 3, 5, 8, 9, 12, 14 и 15). Все они следуют той же схеме. Сначала вы конвертируете входные данные в двухбитное число, где в качестве двойки ставите a, а в качестве B - единицы. Это сделано с этим фрагментом
(({}){}{})
. Затем вы вычитаете значение двухбитового входа, который вы хотите изолировать({}[value])
. (В реальном коде вычитание и преобразование выполняются за один шаг для сохранения байтов). Это может сочетаться с не в случае необходимости:(({}<(())>)){{}{}(((<{}>)))}{}{}
.Далее: и, ни, или, xor, и xnor. Они работают так же, как и выше. Фактически некоторые из них включены выше, однако этот метод короче. Уловка, которую я здесь использовал, заключается в том, что каждый из них соответствует сумме A B. Например, xor оценивается как true, если A + B = 1, и false в противном случае. Сначала вы добавляете AB и вычитаете соответствующую сумму. Выражается как
({}{}[0,1,2 or 3])
. Затем при необходимости провести неДалее: A, B, а не A и не B. Это в значительной степени говорит само за себя. Мы начинаем с удаления ненужного значения, а затем либо отменяем, либо заканчиваем.
Наконец, два простакона: истина и ложь. Для этого мы помещаем правильное значение в стек выключения. В
<>
nilad возвращает ноль , поэтому мы можем сохранить два байта с помощью переключателя в качестве нулевого значения.Не самое эффективное решение там (возможно, самое эффективное в Brain-Flak), но мне было очень весело писать их, и я умоляю вас попытаться сократить их.
источник
(<>)
достаточно дляfalse
; также(<{}{}>)
8 байтов(<>)
оставит входы и поместит ноль в другой стек.<>
достаточно лиfalse
из-за неявных нулей? Также, думаю,a
может быть пустая программа.true
может быть<>[][]
(не сохраняет байты, но выглядит здорово: P).ProgFk ,
18,517,5 байтПоскольку инструкции ProgFk указаны в полубайтах, приведенный ниже код представлен в шестнадцатеричном формате, по одному логическому элементу на строку и с пробелами между байтами.
объяснение
ProgFk - это основанный на ленте esolang (аналог Brainfuck), в котором каждая ячейка является битом, а инструкции приведены в виде полубайтов (4 байта). Инструкции работают с ячейкой, на которую указывает указатель инструкции. Входные дан в первой и второй клеток (с
A
иB
быть первой и второй клетки , соответственно), а указатель команд начинается с первой ячейки. Вывод сохраняется в первой ячейке.Каждая используемая инструкция объясняется ниже.
Сохраненный байт благодаря @LeakyNun!
источник
На самом деле, 24 байта
Эти программы принимают ввод как
A\nB
(с\n
представлением новой строки), который оставляет B на вершине стека, а A ниже.False
представлен0
иTrue
представлен любым положительным целым числом.Спасибо Leaky Nun за 3 байта
источник