Question

什么是XAND和XOR？还有一个XNot

Answer 1

XOR是独占或的缩写。它是一个逻辑二元运算符，要求两个操作数之一为真，但不能同时为两个。

所以这些陈述是正确的：

TRUE XOR FALSE
FALSE XOR TRUE

这些陈述是错误的：

FALSE XOR FALSE
TRUE XOR TRUE

确实没有“独占和”（或XAND）这样的东西，因为理论上它与XOR具有相同的确切要求。还没有XNOT，因为NOT是一元运算符，它否定了它的单个操作数（基本上它只是将一个布尔值翻转到它的相反位置），因此它不能支持任何排他性概念。 / p>

Answer 2

伙计们，别吓唬别人（嘿！开个玩笑），但这实际上都是等同和同义词的问题：

首先：

“XAND”在逻辑上并不存在，“XNAND”也不存在，但是“XAND”通常是由一个勤奋而又困惑的初学逻辑学生思考的。（哇！）。它认为，如果有一个XOR（异或）合乎逻辑地存在“XAND”（“异或”AND）。理性的建议是“IAND”（“包含”AND），它也没有被使用或认可。所以：

 XNOR <=> !XOR <=> EQV

所有这些只是描述了一个独特的运算符，称为等价运算符（＆lt; =＆gt;，EQV），所以：

A  |  B  | A <=> B | A XAND B | A XNOR B | A !XOR B | ((NOT(A) AND B)AND(A AND NOT(B)))
---------------------------------------------------------------------------------------
T  |  T  |    T    |     T    |     T    |     T    |                T    
T  |  F  |    F    |     F    |     F    |     F    |                F    
F  |  T  |    F    |     F    |     F    |     F    |                F    
F  |  F  |    T    |     T    |     T    |     T    |                T

只是一个结束评论：当且仅当基本运算符不是一元时，'X'前缀才有可能。所以，XNOR＆lt; =＆gt; NOT XOR＆lt; = / =＆gt; X NOR。

和平。

Answer 3

XOR是独家或。这意味着“XOR中的两个项目之一是真的，但不是两个。”

TRUE XOR TRUE : FALSE
TRUE XOR FALSE : TRUE
FALSE XOR TRUE : TRUE
FALSE XOR FALSE: FALSE

Wikipedia's XOR Article

我没听说过XAND。

Answer 4

在Charles Petzold撰写的题为“Code”的书中，他说有6个门。存在AND逻辑门，OR门，NOR门，NAND门和XOR门。他还提到第6个门简称它为“巧合门”并暗示它不经常使用。他说它具有XOR门的相反输出，因为当XOR门具有等式的两个真或两个假边时，XOR门的输出为“假”，并且XOR门的输出为真的唯一方法是等式中的一个是真的而另一个是假的，无关紧要。巧合恰恰相反，因为如果一个是真的而另一个是假的（并不重要，那么巧合门），那么在这两种情况下它的输出都是“假的”。而巧合门使其输出为“真”的方式是双方都是假的或真的。如果两者都为假，则重合门将评估为真。如果两者都为真，那么在这种情况下，重合门也将输出“真”。

因此，在XOR门输出“假”的情况下，重合门将输出“真”。在异或门输出“真”的情况下，重合门将输出“假”。

Answer 5

嗯......我知道XOR（独家或）以及NAND和NOR。这些是逻辑门，并且具有软件类似物。

基本上他们的表现如下：

只有当两个参数中的一个为真时，XOR才为真，但不是两个。

F XOR F = F
F XOR T = T
T XOR F = T
T XOR T = F

只要两个参数都不成立，NAND就是真的。

F NAND F = T
F NAND T = T
T NAND F = T
T NAND T = F

只有当两个参数都不成立时，NOR才为真。

F NOR F = T
F NOR T = F
T NOR F = F
T NOR T = F

Answer 6

有一个简单的参数可以看到二进制逻辑门的来源，使用已经出现的真值表。

有六个代表交换操作，其中op b == b op a。每个二元运算符都有一个相关的三列真值表来定义它。可以为所有运算符的定义表修复前两列。

考虑第三栏。它是四个二进制数字的序列。有十六种组合，但是交换性的约束有效地从真值表中删除了一行，所以它只有八行。还有两个被淘汰，因为所有的真相或所有的谬误都不是一个有用的门。这些是熟悉的，或者，和xor，以及他们的否定。

Answer 7

除此之外，由于我只是处理它，如果你正在寻找一个“等价门”或“codencedence门”作为你的XAND，你真正拥有的只是“等于”。

如果你考虑一下，从上面给出XOR：

F XOR F = F
F XOR T = T
T XOR F = T
T XOR T = F

我们希望XAND应该是：

F XAND F = T
F XAND T = F
T XAND F = F
T XAND T = T

这不完全一样吗？

F == F = T
F == T = F
T == F = F
T == T = T

Answer 8

没有Xand或Xnot这样的东西。有Nand，与

相反

TRUE and TRUE   : TRUE
TRUE and FALSE  : FALSE
FALSE and TRUE  : FALSE
FALSE and FALSE : FALSE


TRUE nand TRUE   : FALSE
TRUE nand FALSE  : TRUE
FALSE nand TRUE  : TRUE
FALSE nand FALSE : TRUE

Answer 9

众所周知，XOR定义是奇数奇偶校验函数。对于两个输入：

XOR B =（A而非B）或（B而非A）

XOR的补充是XNOR

XNOR B =（A和B）OR（不是A而不是B）

此后，正常的双输入XAND定义为

XAND B = A而非B

补充是XNAND：

XNAND B = B或不是A

这个XAND定义的一个很好的结果是任何双输入二进制函数都可以使用不超过一个逻辑函数或门来简洁地表达。

            +---+---+---+---+
   If A is: | 1 | 0 | 1 | 0 |
  and B is: | 1 | 1 | 0 | 0 |
            +---+---+---+---+
    Then:        yields:     
+-----------+---+---+---+---+
| FALSE     | 0 | 0 | 0 | 0 |
| A NOR B   | 0 | 0 | 0 | 1 |
| A XAND B  | 0 | 0 | 1 | 0 |
| NOT B     | 0 | 0 | 1 | 1 |
| B XAND A  | 0 | 1 | 0 | 0 |
| NOT A     | 0 | 1 | 0 | 1 |
| A XOR B   | 0 | 1 | 1 | 0 |
| A NAND B  | 0 | 1 | 1 | 1 |
| A AND B   | 1 | 0 | 0 | 0 |
| A XNOR B  | 1 | 0 | 0 | 1 |
| A         | 1 | 0 | 1 | 0 |
| B XNAND A | 1 | 0 | 1 | 1 |
| B         | 1 | 1 | 0 | 0 |
| A XNAND B | 1 | 1 | 0 | 1 |
| A OR B    | 1 | 1 | 1 | 0 |
| TRUE      | 1 | 1 | 1 | 1 |
+-----------+---+---+---+---+

请注意，XAND和XNAND缺乏反身性。

如果我们添加与其对应的minterms相对应的编号种类的“异和”，则此XNAND定义是可扩展的。然后XAND必须有ceil（lg（n））或更多输入，未使用的msbs全为零。除非在其他类型的上下文中使用，否则正常类型的XAND没有数字。

各种XAND或XNAND门对解码很有用。

XOR也可扩展为任意数量的位。如果1的数量是奇数，则结果为1，如果是偶数则为0。如果补充XOR的任何输入或输出位，则该函数变为XNOR，反之亦然。

我没有看到XNOT的定义，我将提出一个定义：

让它与高阻抗（Z，无信号，或者可能是零值布尔型对象）相关。

0xnot 0 = Z
0xnot 1 = Z
1xnot 0 = 1
1xnot 1 = 0

Answer 10

Wiki上的真相表澄清http://en.wikipedia.org/wiki/Logic_gate 没有XAND，这就是问题合法性第一部分的结束。 [关键是你总是可以不用它。]

我个人错误地认为NAND和NOR的XNOT（也不存在），理论上你只需要制作所有其他门link

我认为这种混淆源于你可以使用NAND或NOR（创建其他所有东西[但它们不需要在一起]）的事实，所以它被认为是NAND和NOR一起的一件事，基本上留下心思取代剩下的名字XNOT，这是不被使用的，所以我错误地称之为XNOT，这意味着它是NAND或NOR。

我想在快速讨论中也可能错误地尝试使用XAND，就像我做XNOT一样，指的是“单个门（以各种方式复制）使所有其他门”成为逻辑现实。

Answer 11

异或（不是，不是两者）B＆＃39; 0110＆＃39;是反过来的（双重）IFF（当且仅当）B＆＃39; 1001＆＃39;。

Answer 12

这就是你要找的东西： https://en.wikipedia.org/wiki/XNOR_gate

这是逻辑表：

A B   XOR XNOR
0 0   0   1 
0 1   1   0
1 0   1   0
1 1   0   1

XNOR有时被称为XAND。

Answer 13

XOR表现得像奥斯丁所解释的那样，作为一个异或，无论是A还是B，都不是两者兼而且都不会产生错误。

两个输入有16个可能的逻辑运算符，因为真值表由4个组合组成，有16种可能的方法来排列两个布尔参数和相应的输出。

根据this wikipedia article

，他们都有名字

Answer 14

看看

x   y      A    B   C   D   E   F   G   H   I   J   K   L   M   N

·   ·      T    ·   T   ·   T   ·   T   ·   T   ·   T   ·   T   ·
·   T      ·    T   T   ·   ·   T   T   ·   ·   T   T   ·   ·   T
T   ·      ·    ·   ·   T   T   T   T   ·   ·   ·   ·   T   T   T
T   T      ·    ·   ·   ·   ·   ·   ·   T   T   T   T   T   T   T

A) !(x OR y)    
B) !(x) AND y   
C) !(x) 
D) x AND !(y)   
E) !(y) 
F) x XOR y  
G) !(x AND y)   
H) x AND y  
I) !(x XOR y)   
J) y    
K) !(x) OR y    
L) x    
M) x OR !(y)    
N) x OR y

Answer 15

首先是逻辑，然后是名称，可能是在之前的命名上形成的。

因此0 + 0 = 0; 0 + 1 = 1; 1 + 0 = 1; 1 + 1 = 1 - 由于某种原因，这被称为OR。

然后0-0 = 0; 0-1 = 1; 1-0 = 1; 1-1 = 0 - 它看起来像OR，但是......让它称之为XOR。

0 * 0 = 0; 0 * 1 = 0; 1 * 0 = 0; 1 * 1 = 1 - 由于某种原因，这称为AND。

然后0~0 = 0; 0〜1 = 0; 1〜0 = 0; 1~1 = 0 - 它看起来像AND，但是......让它称之为XAND。

Answer 16

OMG，一个XAND门确实存在。我父亲正在上一份技术课，而且还有一个XAND门。人们都说OR和AND都是完整的对立面，因此他们将其扩展为独占门逻辑：

XOR：一个或另一个，但不是两个。

Xand：一个和另一个，但不是两个。

这是不正确的。如果您要从XOR更改为XAND，则必须翻转“AND”和“OR”的每个实例：

XOR：一个或另一个，但不是两个。

XAND：一个和另一个，但不是一个。

因此，当且仅当两个输入相等时，如果输入为0/0或1/1

，则XAND为真

Answer 17

在大多数情况下，您不会在编程中找到Xand，Xor，nand和Logical运算符，但不要担心，在大多数情况下，您无法使用其他运算符对其进行仿真。

由于您未指定任何特定语言。我也不会做任何特定的语言。在我的示例中，我们将使用以下变量。

A = 3 B = 5 C = 7

对于代码，我将其放在代码标签中，以便于查看自己所做的事情，我还将按照逻辑说明整个过程，以显示最终结果。

NAND

也称为Not And，可以使用Not运算符（通常表示为！）轻松进行模拟

您可以执行以下操作

if(!((A>B) && (B<C)))

如果（！（F && T））
  if（！（F））
  If（T）

在上面的示例中，这是正确的，因为双方都不正确。从而给我们理想的结果

NOR

也称为Not OR，就像NAND一样，我们可以使用not运算符对其进行仿真。
if(!((A>B) || (B<C)))

如果（！（F || T））
  if（！（T））
  if（F）

这将再次为我们带来预期的结果

XOR

“异或”或“异或”仅在一个为TRUE而另一个为FALSE时为真

If (!(A > C && B > A) && (A > C || B > A) )

如果（！（F && T）&&（F || T））
  如果（！（F）&&（T））
  如果（T && T）
  如果是（T）

因此，这是一个仅适用于1或另一个为true的示例，我将说明如果两个均为true，则它将为false。

If ( !(A < C && B > A) && (A < C || B > A) )

If（！（T && T）&&（T || T））
  如果是（！（T）&&（T））
  如果（F && T）
  如果是（F）

而且都是假的

If (!(A > C && B < A) && (A > C || B < A) )

如果（！（F && F）&&（F || F））
  如果（！（F）&&（F））
  如果（T && F）
  如果（F）

和图片有帮助

XAND

最后是我们的“与”，仅当双方均为假或双方均为真时，才返回true。当然，您可以将其称为非XOR（NXOR）

均为真 If ( (A < C && B > A) || !(A < C || B > A) )

如果（（T && T）||！（T || T））
  IF（T ||！T）
  如果（T || F）
  IF（T）

都是错误的 If ( (A > C && B < A) || !(A > C || B < A) )

如果（（F && F）||！（F || F））
  如果（F ||！F）
  如果（F || T）
  如果是（T）

最后一个为1，另一个为false。 If ((A > C && B > A) || !(A > C || B > A) )

如果（（（F && T）||！（F || T）））
  如果（F || !!（T））
  如果（F || F）
  如果（F）

或者如果您想走NXOR路线...
If (!(!(A > C && B > A) && (A > C || B > A)))

If（！（！（F && T）&&（F || T）））
  如果（！（！（F）&&（T）））
  如果（！（T && T））
  如果（！（T））
  如果是（F）

当然，其他所有人的解决方案也都可以说明这一点，我在这里输入自己的答案，因为最主要的答案似乎并不了解并非所有语言都支持XOR或XAND，例如C对XOR使用^且XAND甚至都不支持。

因此，我提供了一些示例，说明在您的语言不像其自己的Php {if ($a XOR $B)这样的运算符不支持XOR或XAND的情况下如何使用基本运算符对其进行仿真。

至于Xnot是什么？不独家吗？所以不是吗？我不知道在逻辑门中会怎样，我认为它不存在。由于Not不仅将输出从1转换为0，然后将0转换为1。

无论如何都希望有帮助。

什么是XAND和XOR

17 个答案: