Pregunta

¿Cómo se hace la operación XOR bit a bit si sólo tiene disponible el AND y OR operaciones?

¿Fue útil?

Solución

La creación de mi propio lenguaje de scripts - ChrisScript - sólo tiene algo como: 

#!/bin/chrish

bit XOR (bit A, bit B)
{
   bit notA;
   bit notB;

   IF (A == 0) notA = 1 ELSE notA = 0;
   IF (B == 0) notB = 1 ELSE notB = 0;

   F = ((A && notB) || (notA && B));

   RETURN F;
}

Incluso sin NO, que puede ser emulado como este. Pero esta es la mejor solución que va a recibir sin tener algún tipo de inversor. Me resulta difícil creer que no tiene algún tipo de inversor liviano - ¿qué entorno de programación está usando

Otros consejos

Tabla de verdad para y 

  A  B  AND
  T  T  T
  T  F  F
  F  T  F
  F  F  F

tabla de verdad para O 

  A  B  OR
  T  T  T
  T  F  T
  F  T  T
  F  F  F

Tabla de verdad para XOR 

  A  B  XOR
  T  T  F
  T  F  T
  F  T  T
  F  F  F

Así, XOR es como O, excepto que es falsa si A y B son verdaderas.

Así que, (A o B) Y (NO (A y B)), que es (A o B) y (A NAND B) 

  A  B  OR  AND NAND [(A OR B) AND (A NAND B)]
  T  T  T    T    F        F
  T  F  T    F    T        T
  F  T  T    F    T        T
  F  F  F    F    T        F

No estoy seguro si se puede hacer sin NOT o NAND

"Los sistemas ({T, F}, y) y ({T, F}, o) son monoides."

"El sistema ({T, F}, xor) es un grupo abeliano", que tiene la propiedad de invertibilidad a diferencia monoides.

Por lo tanto, 'y' y 'o' fallan para construir operación 'xor'.

Fuente: https://en.wikipedia.org/wiki/Exclusive_or#Relation_to_modern_algebra

Si usted tiene operadores aritméticos como + y - además de AND bit a bit (&) y OR (|), entonces usted puede hacer XOR bit a bit como esto: 

int bitwise_XOR(int a, int b)
{
    return (a + b) - (a & b) - (a & b);
}

La razón por la que esto funciona es que estamos haciendo un complemento completo, lo cual es equivalente a XOR cuando la suma de la posición de bit dada es amy <= 1, y entonces estamos corrección para el caso en el que se genera un acarreo (1 + 1) restando 2 * (a & b).

Tenga en cuenta que esto funciona incluso cuando el desbordamiento términos intermedia, asumiendo que tenemos "normalmente se comportó" enteros (complemento a 2, módulo 2 envolvente para el desbordamiento, etc).

la entrada de Wikipedia sobre XOR alto esto en detalle. Probablemente un buen primer lugar para comprobar antes de aksing una pregunta SO.

Si ya tiene partes que no se preocupan por enmascarados fuera, me parece la forma más fácil de hacerlo (por lo que escribir el código va de todos modos) es simplemente usar el operador no igual.

(a XOR b) = ((a OR b) - (a AND b)), or in other words, the union set minus the intersection set.

Code example (in javascript):

var a = 5;
var b = 12;
var xor = (a | b) - (a & b); // result: 9

In C: x ^ y = (x & ~y) | (~x & y)

i am pretty sure that the formula below is correct:

a xor b = not((a and b) or not(a+b))

Best advice is to look up XOR in reference manuals and encyclopedia sites on the net and then write code or script which does the same as the description of what a XOR built-in function does and use your own return or status values. We can not tell you how to do that type of bit compares from within the software community.

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top