逻辑门

Question

制作一个模拟基本逻辑门的程序。

输入:一个大写单词，后面跟着21位二进制数字，用空格分隔，如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

这是合作伙伴，所以最短的代码就赢了。

Answer 1

Python 2，38字节

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

在网上试试！

一个很好的ol‘模块链应用于输入字符串的ASCII值之和，使解决方案变得过于合适。对于每个可能的输入，ASCII值是不同的，除了0 1和1 0的输入结果是相同的，这是因为所有使用的逻辑门都是对称的。

对于仅在比特中不同的输入，*3分离出其他相邻的值，因为这使得mod链很难拆分。在mod链中，数字的长度和大小创造了大约正确的熵量来适应18个二进制输出。

使用hash(s)或id(s)当然可以使用更短的解决方案，但我避免使用这些解决方案，因为它们依赖于系统。

Python 2，50字节

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

在网上试试！

一个稍微有原则的解决方案。每个逻辑门对输入中的每一个零数都给出了不同的结果，可以编码为一个3位数，从1到6。每个可能的逻辑门都通过(s*9)[35]映射到相应的数字，所有这些都是不同的。对于OR，这最终会读取其中一个位，以便字符可以是0或1，但最终可以检查它是否是0，并且1无论如何都会正确地给出1结果。

Answer 2

JavaScript (ES6)，39字节

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

在网上试试！

怎么做？

我们不能用parseInt()解析空间，不管我们使用的是哪个基。所以我们给输入字符串注入一个基-64表示。这可能会生成=填充字符(这些字符也不能用parseInt()解析)，但这些字符肯定位于字符串的末尾，可以安全地忽略这些字符。

我们将解析为基本的34，并应用一个模块化的86，然后是一个模块化的23，这给出了以下结果。这包括由于精度下降而造成的不准确。最后的结果是在[0..19]中，最高的真实指数是在18，导致了一个19位的查找位掩码。

 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

Answer 3

CJam (13字节)

q1bH%86825Yb=

假设输入没有尾随换行符。

在线测试套件

这只是一个简单的散列，它将24个可能的输入映射到17个不同但一致的值中，然后在压缩表中查找它们。

Python2(36个字节)

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

这只是上面CJam答案的一个端口。测试套件使用xnor的测试框架。