Domanda

Come si fa a fare l'operazione XOR bit a bit se si ha a disposizione solo il AND e OR operazioni?

È stato utile?

Soluzione

creare il mio linguaggio di scripting - ChrisScript - una cosa solo bisogno di simile: 

#!/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;
}

Anche senza NON, può essere emulato in questo modo. Ma questa è la soluzione migliore che si vuole ottenere senza avere una qualche forma di inverter. Trovo difficile credere che non si dispone di una qualche forma di inverter availble -? Quale ambiente di scripting stai usando

Altri suggerimenti

tabella di verità per E 

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

tabella di verità per OR 

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

tabella di verità per XOR 

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

Quindi, XOR è proprio come O, tranne che è falso se A e B sono vere.

Quindi, (A o B) AND (NOT (A e B)), che è (A o B) e (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

Non so se può essere fatto senza NON o NAND

"I sistemi ({T, F}, e) e ({T, F}, o) sono monoidi".

"Il sistema ({T, F}, xor) è un gruppo abeliano", che ha la proprietà di dell'invertibilità differenza monoidi.

Pertanto, 'e' e 'o' sicuro per costruire operazione 'xor'.

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

Se si dispone di operatori aritmetici, come + e - oltre a bit AND (&) e OR (|), allora si può fare XOR bit a bit in questo modo: 

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

Il motivo per cui funziona è che stiamo facendo un add completa, che equivale a XOR quando la somma per la posizione amy data bit è <= 1, e quindi stiamo correggendo per il caso in cui si genera un riporto (1 + 1) sottraendo 2 * (a & b).

Si noti che questo funziona anche quando i termini di overflow intermedio, assumendo abbiamo "normalmente si è comportato" numeri interi (complemento a 2, modulo 2 avvolgente per troppo pieno, ecc).

ingresso di Wikipedia su XOR va oltre questo in dettaglio. Probabilmente un buon primo posto per verificare prima di poter richiedere una domanda SO.

Se si dispone già di parti che non interessano mascherato fuori, mi sembra il modo più semplice per farlo (per quanto riguarda la scrittura del codice va in ogni caso) è usare solo il proprio operatore non uguale.

(a XOR b) = ((a OR b) - (a AND b)), o in altre parole, il set di unione meno il set di intersezione.

Esempio di codice (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.

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top