Сделайте программу, которая имитирует основные логические элементы.

Ввод: слово из заглавных букв, за которым следуют 2 однозначные двоичные числа, разделенные пробелами, например OR 1 0. Ворота OR, AND, NOR, NAND, XOR, и XNORнеобходимы.

Выходные данные: Какой выходной сигнал введенного логического элемента будет иметь два числа: 1 или 0.

Примеры:
AND 1 0 становится 0
XOR 0 1становится 1
OR 1 1становится 1
NAND 1 1становится0

Это Codegolf, поэтому выигрывает самый короткий код.

Желе , 13 10 байт

OSị“ʋN’BŻ¤

Попробуйте онлайн!

Порт Питер Тейлор ответ.

Python 2 , 38 байт

lambda s:sum(map(ord,s))*3%61%37%9%7%2

Попробуйте онлайн!

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

*3Выделяется в противном случае-смежные значения для входов , которые отличаются только в битах, так как это делает его трудно для мод цепи дробить. Длина и размер чисел в цепочке модов создает примерно правильное количество энтропии для 18 бинарных выходов.

Более короткое решение, безусловно, возможно с использованием hash(s)или id(s), но я избегал их, потому что они зависят от системы.

Python 2 , 50 байт

lambda s:'_AX0NRD'.find((s*9)[35])>>s.count('0')&1

Попробуйте онлайн!

Несколько более принципиальное решение. Каждый логический вентиль дает различный результат для каждого счетчика нулей на входе, кодируемый как трехбитовое число от 1 до 6. Каждый возможный логический вентиль сопоставляется с соответствующим числом путем взятия (s*9)[35], которые все различны. Поскольку OR, это завершает чтение одного из битов, чтобы символ мог быть 0или 1, но оказывается, что он работает, чтобы проверить, если это так 0, и a 1в 1любом случае правильно даст результат.

JavaScript (ES6), 39 байт

s=>341139>>parseInt(btoa(s),34)%86%23&1

Попробуйте онлайн!

Как?

Мы не можем анализировать пробелы parseInt(), независимо от того, с какой базой мы работаем. Таким образом, вместо этого мы вводим представление base-64 входной строки. Это может генерировать =символы заполнения (которые не могут быть проанализированы сparseInt() ни одним из них), но эти гарантированно находятся в конце строки и могут быть безопасно проигнорированы.

$34$$86$$23$$[0..19]$$18$

 input      | to base-64     | parsed as base-34 | mod 86 | mod 23 | output
------------+----------------+-------------------+--------+--------+--------
 "AND 0 0"  | "QU5EIDAgMA==" |  1632500708709782 |   26   |    3   |    0
 "AND 0 1"  | "QU5EIDAgMQ==" |  1632500708709798 |   42   |   19   |    0
 "AND 1 0"  | "QU5EIDEgMA==" |  1632500708866998 |   34   |   11   |    0
 "AND 1 1"  | "QU5EIDEgMQ==" |  1632500708867014 |   50   |    4   |    1
 "OR 0 0"   | "T1IgMCAw"     |     1525562056532 |   52   |    6   |    0
 "OR 0 1"   | "T1IgMCAx"     |     1525562056533 |   53   |    7   |    1
 "OR 1 0"   | "T1IgMSAw"     |     1525562075028 |   58   |   12   |    1
 "OR 1 1"   | "T1IgMSAx"     |     1525562075029 |   59   |   13   |    1
 "XOR 0 0"  | "WE9SIDAgMA==" |  1968461683492630 |   48   |    2   |    0
 "XOR 0 1"  | "WE9SIDAgMQ==" |  1968461683492646 |   64   |   18   |    1
 "XOR 1 0"  | "WE9SIDEgMA==" |  1968461683649846 |   56   |   10   |    1
 "XOR 1 1"  | "WE9SIDEgMQ==" |  1968461683649862 |   72   |    3   |    0
 "NAND 0 0" | "TkFORCAwIDA=" | 61109384461626344 |   62   |   16   |    1
 "NAND 0 1" | "TkFORCAwIDE=" | 61109384461626350 |   70   |    1   |    1
 "NAND 1 0" | "TkFORCAxIDA=" | 61109384461665650 |   64   |   18   |    1
 "NAND 1 1" | "TkFORCAxIDE=" | 61109384461665656 |   72   |    3   |    0
 "NOR 0 0"  | "Tk9SIDAgMA==" |  1797025468622614 |   76   |    7   |    1
 "NOR 0 1"  | "Tk9SIDAgMQ==" |  1797025468622630 |    6   |    6   |    0
 "NOR 1 0"  | "Tk9SIDEgMA==" |  1797025468779830 |   84   |   15   |    0
 "NOR 1 1"  | "Tk9SIDEgMQ==" |  1797025468779846 |   14   |   14   |    0
 "XNOR 0 0" | "WE5PUiAwIDA=" | 66920415258533864 |    0   |    0   |    1
 "XNOR 0 1" | "WE5PUiAwIDE=" | 66920415258533870 |    8   |    8   |    0
 "XNOR 1 0" | "WE5PUiAxIDA=" | 66920415258573170 |    2   |    2   |    0
 "XNOR 1 1" | "WE5PUiAxIDE=" | 66920415258573176 |   10   |   10   |    1

CJam (13 байт)

q1bH%86825Yb=

Предполагается, что ввод без завершающей строки.

Набор онлайн-тестов

Это простой хеш, который отображает 24 возможных входа в 17 различных, но согласованных значений, а затем просматривает их в сжатой таблице.

Python 2 (36 байт)

lambda s:76165>>sum(map(ord,s))%17&1

Это просто порт ответа CJam выше. Тестовый набор с использованием среды тестирования xnor.

05AB1E , 13 12 10 8 байт

ÇO₁*Ƶï%É

Порт альтернативного расчета @mazzy, упомянутый в комментарии к его ответу Powershell ( *256%339%2вместо *108%143%2).

Попробуйте онлайн или проверьте все контрольные примеры .

Объяснение:

Ç            # Convert each character in the (implicit) input to a unicode value
 O           # Sum them together
  ₁*         # Multiply it by 256
    Ƶï%      # Then take modulo-339
        É    # And finally check if it's odd (short for %2), and output implicitly

Посмотрите эту подсказку 05AB1E (раздел Как сжать большие целые числа? ), Чтобы понять, почему Ƶïэто так 339.

Древесный уголь , 32 байта

§01÷⌕⪪”＆⌈4Ｙ⍘ＬH⦄vü|⦃³Ｕ}×▷” Ｓ∨⁺ＮＮ⁴

Попробуйте онлайн! Ссылка на подробную версию кода. Объяснение: Сжатая строка расширяется до списка поддерживаемых операций, так что индекс данной операции затем сдвигается вправо в соответствии с входными данными, и извлеченный таким образом бит становится результатом.

XOR     001
AND     010
OR      011
NOR     100
NAND    101
XNOR    110
inputs  011
        010

74-байтовая версия работает для всех 16 бинарных операций, которые я произвольно назвал следующим образом: НОЛЬ И МЕНЬШЕ ВТОРОЕ БОЛЬШОЕ ПЕРВЫЙ XOR ИЛИ NOR XNOR ПЕРВЫЙ NGREATER NSECOND NLESS NAND NZERO.

§10÷÷⌕⪪”＆↖VρＳ´↥cj/v⊗J[Rf↓⪫？9ＫO↘Ｙ⦄;↙W´Ｃ>η=⁴⌕✳AＫＸIＢ｜⊖\`⊖:Ｂ�Ｊ/≧vF@$h⧴” Ｓ∨Ｎ²∨Ｎ⁴

Попробуйте онлайн! Ссылка на подробную версию кода.

Mathematica, 55 байт

Symbol[ToCamelCase@#][#2=="1",#3=="1"]&@@StringSplit@#&

Чистая функция. Принимает строку как ввод и возвращает Trueили Falseкак вывод. Так как Or, And, Nor, Nand, Xor, и Xnorвсе встроенные модули, мы используем , ToCamelCaseчтобы изменить оператор в Паскале случае, преобразовать его в эквивалентный символ, и применить его к двум аргументам.

J , 21 байт

2|7|9|37|61|3*1#.3&u:

Попробуйте онлайн!

Порт решения xnor's Python 2 .

J , 30 байт

XNOR=:=/
NAND=:*:/
NOR=:+:/
".

Попробуйте онлайн!

Некоторые немного удовольствия с Eval ".и стандартной библиотеки (которая уже включает в себя правильно AND, OR, XOR).

J , 41 байт

({7 6 9 8 14 1 b./)~1 i.~' XXNNA'E.~_2&}.

Попробуйте онлайн!

Более J-стиль подхода.

Как это устроено

Очень общий трюк J спрятан здесь. Часто желаемая функция имеет структуру «Делай F на одном входе, делай H на другом, а затем делай G на обоих результатах». Тогда это должно работать как (F x) G H y. В молчаливой форме это эквивалентно (G~F)~H:

x ((G~F)~H) y
x (G~F)~ H y
(H y) (G~F) x
(H y) G~ F x
(F x) G H y

Если Gэто асимметричный примитив, просто поменяйте местами левый и правый аргументы целевой функции, и мы можем сохранить байт.

Теперь перейдем к ответу выше:

({7 6 9 8 14 1 b./)~1 i.~' XXNNA'E.~_2&}.

1 i.~' XXNNA'E.~_2&}.  Processing right argument (X): the operation's name
                _2&}.  Drop two chars from the end
1 i.~' XXNNA'E.~       Find the first match's index as substring
                       Resulting mapping is [OR, XOR, XNOR, NOR, NAND, AND]

7 6 9 8 14 1 b./  Processing left argument (Y): all logic operations on the bits
7 6 9 8 14 1 b.   Given two bits as left and right args, compute the six logic functions
               /  Reduce by above

X{Y  Operation on both: Take the value at the index

Powershell, 36 34 байта

Вдохновлен xnor , но последовательность *108%143%2короче оригинала*3%61%37%9%7%2

$args|% t*y|%{$n+=108*$_};$n%143%2

Тестовый скрипт:

$f = {

 $args|% t*y|%{$n+=108*$_};$n%143%2
#$args|% t*y|%{$n+=3*$_};$n%61%37%9%7%2   # sequence by xnor

}

@(
    ,("AND 0 0", 0)
    ,("AND 0 1", 0)
    ,("AND 1 0", 0)
    ,("AND 1 1", 1)
    ,("XOR 0 0", 0)
    ,("XOR 0 1", 1)
    ,("XOR 1 0", 1)
    ,("XOR 1 1", 0)
    ,("OR 0 0", 0)
    ,("OR 0 1", 1)
    ,("OR 1 0", 1)
    ,("OR 1 1", 1)
    ,("NAND 0 0", 1)
    ,("NAND 0 1", 1)
    ,("NAND 1 0", 1)
    ,("NAND 1 1", 0)
    ,("NOR 0 0", 1)
    ,("NOR 0 1", 0)
    ,("NOR 1 0", 0)
    ,("NOR 1 1", 0)
    ,("XNOR 0 0", 1)
    ,("XNOR 0 1", 0)
    ,("XNOR 1 0", 0)
    ,("XNOR 1 1", 1)

) | % {
    $s,$e = $_
    $r = &$f $s
    "$($r-eq$e): $s=$r"
}

Выход:

True: AND 0 0=0
True: AND 0 1=0
True: AND 1 0=0
True: AND 1 1=1
True: XOR 0 0=0
True: XOR 0 1=1
True: XOR 1 0=1
True: XOR 1 1=0
True: OR 0 0=0
True: OR 0 1=1
True: OR 1 0=1
True: OR 1 1=1
True: NAND 0 0=1
True: NAND 0 1=1
True: NAND 1 0=1
True: NAND 1 1=0
True: NOR 0 0=1
True: NOR 0 1=0
True: NOR 1 0=0
True: NOR 1 1=0
True: XNOR 0 0=1
True: XNOR 0 1=0
True: XNOR 1 0=0
True: XNOR 1 1=1

Perl 6 , 20 байт

*.ords.sum*108%143%2

Попробуйте онлайн!

Подход порта Мэдди . В качестве альтернативы *256%339%2также работает.

Perl 6 , 24 байта

*.ords.sum*3%61%37%9%7%2

Попробуйте онлайн!

Порт ответа от xnor . Я попытаюсь найти более короткий, но я думаю, что это, вероятно, лучшее, что есть.

JavaScript (Node.js) , 106 94 байта

x=>([a,c,d]=x.split` `,g=[c&d,c^d,c|d]["OR".search(a.slice(1+(b=/N[^D]/.test(a))))+1],b?1-g:g)

Попробуйте онлайн!

Ссылка на код и все 24 случая.

+9 за забытый на карту случай XNOR.

Java 10, 30 28 байт

s->s.chars().sum()*108%143%2

Порт ответа @mazzy 's Powershell .

Попробуйте онлайн.

JavaScript (Node.js) , 45 байт

Просто порт превосходного ответа Python 2 от xnor, опубликованный с согласия, пожалуйста, вместо этого дайте этот ответ.

x=>Buffer(x).reduce((a,b)=>a+b)*3%61%37%9%7%2

Попробуйте онлайн!

Атташе , 55 байт

{Eval!$"${Sum!Id''Downcase!SplitAt!_}${N=>__2}"}@@Split

Попробуйте онлайн!

Довольно грубое решение. Преобразует ввод в соответствующую команду Attache и оценивает ее. (Attache имеет встроенные модули для каждого из 6 логических элементов.)

Рубин , 20 байтов

->s{76277[s.sum%17]}

Попробуйте онлайн!

Как это устроено:

В основном так же, как ответ Питера Тейлора, но Руби облегчает. Магическое число отличается, но идея была та же.