XOR eller exclusive er en boolsk logikkoperasjon som er mye brukt i kryptografi og genererer paritetsbiter for feilkontroll og feiltoleranse. Operasjonen tar inn to innganger og produserer en enkelt utgang. Operasjonen er bitvis tradisjonelt, men kan også utføres logisk. Denne artikkelen vil lære deg hvordan du får inn den logiske XOR for to variabler Python .
XOR av to tall
Som XOR er en bitvis operatør , vil den sammenligne biter av begge heltall bit for bit etter å ha konvertert dem til binære tall. Sannhetstabellen for XOR (binær) er vist nedenfor:
| EN | B | A⊕B |
|---|---|---|
| 1 | 1 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 0 | 0 | 0 |
Formelen for XOR-operasjon er:
XOR(A, B) = ( A .overline{B}) + (B.overline{A})>Å utføre XOR av to heltall er trivielt i Python, ettersom språket tilbyr en operator, spesielt for dette formålet, nemlig en caret ^. Men denne operasjonen kan også oppnås ved å bruke operatørmodulen i Python.
Merk: Et par ting å huske på når du utfører xor-operasjonen:
linux tastatursnarveier
- XOR skal bare være mellom homogene elementer, dvs. datatypen deres skal være den samme.
- Bool av en streng vil resultere i ekte hvis strengen ikke er tom og Falsk hvis strengen er tom.
La oss nå se XOR-operasjonen på forskjellige datatyper i Python.
XOR på heltall
Heltallene konverteres først til binære tall og deretter sammenlignes hver bit med hverandre. Det endelige svaret blir deretter igjen konvertert tilbake til den opprinnelige heltallsformen. Den følgende koden demonstrerer bruken av en caret for å utføre XOR av to heltallsvariabler.
Eksempel: Først ble to variabler initialisert som inneholder 10 og 27 heltallsverdier. Deretter oppnås xor av de to variablene ved å bruke indikatoroperatoren. Resultatet av operasjonen vises.
Python
# First integer a = 10 # Second integer b = 27 # Performing the xor and storing the result in separate variable xor = a ^ b print(xor)>
Produksjon:
17>
Tidskompleksitet: O(1)
Romkompleksitet: O(1)
XOR på boolsk
XOR for to boolske variabler er ganske enkel. Utdata fra XOR-operasjonen er enten 0 eller 1 som representerer henholdsvis True eller Flase i boolsk format. Derfor, for å få den logiske XOR for boolsk datatype, er enten True eller False gitt som inngangsverdier.
Eksempel: Først ble to boolske variabler initialisert med en verdi, og deretter utføres XOR-operasjonen på dem ved hjelp av caret-operatoren.
Python # First boolean a = True # Second boolean b = False # Performing the xor operation xor = a ^ b print(xor)>
Produksjon:
java print
True>
Tidskompleksitet: O(1)
Romkompleksitet: O(1)
XOR på streng
Siden strenger er en sekvens, må datatypen normaliseres for at operasjonen skal utføres på dem. Derfor ville strengene bli konvertert til bool, og deretter kunne xor-operasjonen utføres på dem. Men på grunn av dette vil resultatet av operasjonen være binært, dvs. det vil resultere i begge ekte eller Falsk (i motsetning til xor av heltall der resulterende verdi produseres).
Eksempel: Først defineres to strenger. En av dem er en tom streng. Deretter konverteres strengene til den boolske datatypen, og xor-operasjonen utføres på dem. Resultatet vises.
Python # First string a = 'Hello World!' # Second string b = '' # Performing the xor operation xor = bool(a) ^ bool(b) print(xor)>
Produksjon:
True>
Tidskompleksitet: O(n)
Romkompleksitet: O(n), der n er lengden på strengen
java heltall
XOR av to variabler ved bruk av operatørmodul
Python har en operatørmodul, som gir et sett med forhåndsdefinerte funksjoner for aritmetiske, logiske, bitvise og sammenligningsoperatorer. Den gir også XOR-funksjonen til den bitvise operatoren som kan brukes til å få XOR for to variabler.
Eksempel: Importer først operatørmodulen. Deretter initialiseres to variabler med en verdi, og deretter utføres XOR-operasjonen på dem ved å bruke operatørmodulenes xor-funksjon.
Python # import module import operator # First integer a = 10 # Second integer b = 27 # Performing the xor using operator module xor = operator.xor(a,b) print(xor)>
Produksjon:
17>
Tidskompleksitet: O(1)
Romkompleksitet: O(1)
Bytte to heltall ved hjelp av XOR uten midlertidig variabel
Den bitvise XOR-operasjonen i Python kan også brukes til å bytte to heltall uten å bruke den midlertidige variabelen. La oss se hvordan dette fungerer.
a = a ^ b b = a ^ b a = a ^ b>
Bytting krever tre uttrykk med XOR-operasjonen.
hashtabell versus hashmap
- XOR de to heltallene 'en' og ' b' og lagre resultatet i heltall 'en' seg selv.
- Nå XOR den oppdaterte verdien av 'en' med 'b'. Dette vil resultere i den opprinnelige verdien av 'en' , som nå er lagret i 'b' .
- Til slutt, XOR 'en' med den nå oppdaterte verdien på 'b' i forrige trinn. Resultatet vil være den opprinnelige verdien av 'b' . som nå er lagret i 'en' .
Eksempel: Først initialiseres to heltall. Deretter ved å bruke de tre trinnene ovenfor, byttes to heltall ved å bruke XOR-karetoperatoren. Skriv til slutt ut de byttede heltallene.
Python # First integer a = 10 # Second integer b = 27 print('Before Swapping:') print('a =', a) print('b =', b) # swapping integers using XOR a = a ^ b b = a ^ b a = a ^ b print('After Swapping:') print('a =', a) print('b =', b)> Produksjon:
Before Swapping: a = 10 b = 27 After Swapping: a = 27 b = 10>