手动逻辑门

13

编写一个模拟基本逻辑门的程序。

输入：一个全大写单词，后跟2个1位二进制数字，以空格分隔，例如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，所以最短的代码获胜。

code-golf  logic-gates  hashing  code-golf  code-golf  number  array-manipulation  integer  code-golf  string  unicode  text-processing  cops-and-robbers  boggle  cops-and-robbers  boggle  code-golf  ascii-art  code-golf  word-puzzle  king-of-the-hill  python  code-golf  sequence  kolmogorov-complexity  code-golf  source-layout  code-golf  string  kolmogorov-complexity  math  number  code-golf  date  code-golf  combinatorics  recursion  game  king-of-the-hill  javascript  code-golf  array-manipulation  code-golf  radiation-hardening  self-referential  code-golf  integer  code-golf  number  code-golf  set-theory  code-golf  sequence  code-golf  string  sorting  natural-language  code-golf  decision-problem  number-theory  primes  code-golf  code-golf  ascii-art  code-challenge  array-manipulation  sorting  rubiks-cube  regular-expression  code-golf  counting  file-system  recursion  code-golf  string  kolmogorov-complexity  color  code-golf  game  code-challenge  permutations  encode  restricted-time  decode  code-golf  math  decision-problem  matrix  integer  palindrome  code-golf  matrix  statistics  king-of-the-hill  king-of-the-hill  python  card-games  code-golf  string  natural-language  code-golf  sequence  number-theory 
— qazwsx
source
我们可以接受数组作为输入吗？
— Quintec '18
没有@Quintec，您不能
— qazwsx
3
我们可以输出为True / False吗？
— xnor
5
确定@xnor（也是相关的用户名）
— qazwsx

Answers:

29

Python 2，38个字节

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

在线尝试！

一个好的ol'模链适用于输入字符串的ASCII值总和，从而提供了一种过拟合的解决方案。每个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

在线尝试！

稍微原则性的解决方案。对于输入中的每个零计数，每个逻辑门给出的结果都不相同，可以将其编码为1到6之间的一个三位数。通过取(s*9)[35]，可以将每个可能的逻辑门映射到相应的数字，它们都是不同的。对于OR，这结束时会读取其中一个位，因此该字符可能是0或1，但事实证明可以检查它是否为0，并且无论如何a 1都会正确给出1结果。

— 异或
source
该死的，我在找我自己的mod值，但是你击败了我。您是否在任何地方都写下了自己的策略，因为我的蛮力方法往往会花费很长时间
— Jo King
2
@JoKing我基本上完全是蛮力的*a%b%c%d%e%2，没有什么真正的聪明。唯一有趣的是*在mod前面放了一个；我没有尝试其他格式。
— xnor
哇，真是令人难以置信！我什至不希望像哈希一样的方法能够做到这一点。我可以为您的答案添加一个45字节的JS端口吗？
— Shieru Asakoto
@ShieruAsakoto当然，去吧。
— xnor18年
1
@xnor我使用的方法与您使用的方法完全相同，所以我自己发布它会感到不舒服，但这可能是36个字节。
— nedla2004 '18 -10-7
10

JavaScript（ES6），39个字节

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

在线尝试！

怎么样？

parseInt()无论我们使用哪个库，都无法使用解析空间。因此，我们改为注入输入字符串的base-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
— Arnauld
source
：o比
— 传达的
但是...似乎不起作用NOR？
— Shieru Asakoto
@ShieruAsakoto感谢您的关注。我只是忘了NOR。现在已修复。
— 阿纳尔德
6

CJam（13字节）

q1bH%86825Yb=

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

在线测试套件

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

Python 2（36字节）

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

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

— 彼得·泰勒
source
4

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。

— 凯文·克鲁伊森
source
3

木炭，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 NFIRST NGREATER NSECOND NLESS NAND NZERO。

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

在线尝试！链接是详细版本的代码。

— 尼尔
source
+1完整的16种操作程序给您留下了深刻的印象！
— THEREALyumdub
3

Mathematica，55个字节

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

纯功能。将字符串作为输入并返回True或False作为输出。因为Or，And，Nor，Nand，Xor，和Xnor全内置插件，我们使用ToCamelCase改变经营者帕斯卡的情况下，将其转换为等值的符号，并将其应用到两个参数。

— 军团哺乳动物978
source
3

J，21个字节

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

在线尝试！

xnor的Python 2解决方案的端口。

J，30个字节

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

在线尝试！

使用eval ".和标准库（已经包含正确的，，）AND，有些有趣。ORXOR

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
— 起泡器
source
如果尚未考虑，请考虑将该技巧发布到J高尔夫技巧中。整洁的东西。我也是评估解决方案的忠实拥护者。
— 科尔
3

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
— 疯狂的
source
1
但是，您*16%95%7%2的XNOR案例失败了。你可以使用@ nedla2004的*6%68%41%9%2，这是短于2个字节@xnor的一个，虽然。
— 凯文·克鲁伊森
1
谢谢！！！！我加了xnor。我认为这*108%143更有吸引力：)另外，还有一对不错的一对*256%339。这对知道如何使用位和字节的语言来说甚至更好。
— mazzy
1
很好！您的答案中的端口也会在我的Java答案中保存2个字节。:)这是我的05AB1E答案的10字节替代方法，方法是使用*256%339。
— 凯文·克鲁伊森
2

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实例。

— 浅香诗人
source
也许我没有看到任何东西，但是我在哪里键入输入？输入选项卡不执行任何操作。
— qazwsx
@qazwsx这是一个lambda函数，默认情况下是允许的。
— Shieru Asakoto
1
@qazwsx链接显示每个可能输入的输出。此答案是一个功能，因此，如果要手动测试它，则可以将页脚替换为例如console.log(f("AND", 1, 1));
— Mego，
@qazwsx 并且请还原降级投票。毕竟这不是无效的。
— Shieru Asakoto
哦，我懂了。我回复了
— 弃用票
1

JavaScript（Node.js），45字节

只是在同意后发布了xnor出色的Python 2答案的一部分，请对此答案进行投票而不是对此进行投票。

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

在线尝试！

— 浅香诗人
source
— 凯文·克鲁伊森
— 凯文·克鲁伊森
将其首先转换为社区答案也许是个好主意？然后在此处添加这些JS端口作为集合。
— Shieru Asakoto
也许。不确定。如果有多个相同字节数的选择，我通常只添加多个答案。mazzy的Powershell答案甚至找到了一个较短的答案：41个字节。
— 凯文·克鲁伊森
1

附件，55字节

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

在线尝试！

一个相当残酷的解决方案。将输入转换为相关的Attache命令并对其求值。（Attache内置了6个逻辑门中的每一个。）

— 科纳·奥布莱恩
source
1

红宝石，20字节

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

在线尝试！

怎么运行的：

基本上与Peter Taylor的答案相同，但是Ruby使它变得更容易。魔术数字不同，但想法是相同的。

— 国标
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.