Find XOR of two number without using XOR operator

Last Updated : 17 Mar, 2025

Given two integers, the task is to find XOR of them without using the XOR operator.

Examples :

Input: x = 1, y = 2
Output: 3
Input: x = 3, y = 5
Output: 6

Approach - Checking each bit - O(log n) time and O(1) space

A Simple Solution is to traverse all bits one by one. For every pair of bits, check if both are the same, set the corresponding bit like 0 in output, otherwise set it as 1.

C++

// C++ program to find XOR without using ^ #include <iostream> using namespace std;  // Returns XOR of x and y int findXor(int x, int y) { 	int res = 0;  	// Assuming 32-bit Integer 	for (int i = 31; i >= 0; i--) { 	     		// Find current bits in x and y 		bool b1 = (x & (1 << i)) != 0? true:false; 		bool b2 = (y & (1 << i)) != 0? true:false; 		 		// If bits are opposite,  		// set i'th bit  		if (b1 != b2) { 		    res = res|(1<<i); 		} 	} 	return res; }  int main() { 	int x = 1, y = 2; 	cout << findXor(x, y); 	return 0; }

Java

// Java program to find XOR without using ^ class GfG {          // Returns XOR of x and y     static int findXor(int x, int y) {         int res = 0;          // Assuming 32-bit Integer         for (int i = 31; i >= 0; i--) {                          // Find current bits in x and y             boolean b1 = (x & (1 << i)) != 0;             boolean b2 = (y & (1 << i)) != 0;                          // If bits are opposite,              // set i'th bit              if (b1 != b2) {                 res = res | (1 << i);             }         }         return res;     }      public static void main(String[] args) {         int x = 1, y = 2;         System.out.println(findXor(x, y));     } }

Python

# Python program to find XOR without using ^  # Returns XOR of x and y def findXor(x, y):     res = 0      # Assuming 32-bit Integer     for i in range(31, -1, -1):                  # Find current bits in x and y         b1 = (x & (1 << i)) != 0         b2 = (y & (1 << i)) != 0                  # If bits are opposite,          # set i'th bit          if b1 != b2:             res = res | (1 << i)      return res  if __name__ == "__main__":     x, y = 1, 2     print(findXor(x, y))

// C# program to find XOR without using ^ using System;  class GfG {          // Returns XOR of x and y     static int findXor(int x, int y) {         int res = 0;          // Assuming 32-bit Integer         for (int i = 31; i >= 0; i--) {                          // Find current bits in x and y             bool b1 = (x & (1 << i)) != 0;             bool b2 = (y & (1 << i)) != 0;                          // If bits are opposite,              // set i'th bit              if (b1 != b2) {                 res = res | (1 << i);             }         }         return res;     }      static void Main() {         int x = 1, y = 2;         Console.WriteLine(findXor(x, y));     } }

JavaScript

// JavaScript program to find XOR without using ^  // Returns XOR of x and y function findXor(x, y) {     let res = 0;      // Assuming 32-bit Integer     for (let i = 31; i >= 0; i--) {                  // Find current bits in x and y         let b1 = (x & (1 << i)) !== 0;         let b2 = (y & (1 << i)) !== 0;                  // If bits are opposite,          // set i'th bit          if (b1 !== b2) {             res = res | (1 << i);         }     }     return res; }  let x = 1, y = 2; console.log(findXor(x, y));

Output

Using AND, OR & NOT Operators - O(1) time and O(1) space

Approach 1:

The idea is to use a combination of OR, AND, and NOT operations to simulate XOR functionality. Since XOR sets a bit when only one of the corresponding bits in the input numbers is set (but not both), we can achieve this by first finding all positions where either bit is set using OR, and then removing positions where both bits are set using a logical trick with complements.
This works through Boolean algebra manipulation. The expression (x | y) & (~x | ~y) can be understood in two parts: (x | y) identifies all bit positions where at least one of x or y has a set bit, while (~x | ~y) is the complement of (x & y) (by De Morgan's law), meaning it has 0 bits only where both x and y have set bits. When we AND these two expressions together, we get 1 only in positions where either x or y (but not both) has a set bit - which is exactly the definition of XOR.

C++

// C++ program to find XOR without using ^ #include <iostream> using namespace std;  // Returns XOR of x and y int findXor(int x, int y) { 	return (x | y) & (~x | ~y); }  int main() { 	int x = 1, y = 2; 	cout << findXor(x, y); 	return 0; }

Java

// Java program to find XOR without using ^ class GfG {          // Returns XOR of x and y     static int findXor(int x, int y) {         return (x | y) & (~x | ~y);     }      public static void main(String[] args) {         int x = 1, y = 2;         System.out.println(findXor(x, y));     } }

Python

# Python program to find XOR without using ^  # Returns XOR of x and y def findXor(x, y):     return (x | y) & (~x | ~y)  if __name__ == "__main__":     x, y = 1, 2     print(findXor(x, y))

// C# program to find XOR without using ^ using System;  class GfG {          // Returns XOR of x and y     static int findXor(int x, int y) {         return (x | y) & (~x | ~y);     }      static void Main() {         int x = 1, y = 2;         Console.WriteLine(findXor(x, y));     } }

JavaScript

// JavaScript program to find XOR without using ^  // Returns XOR of x and y function findXor(x, y) {     return (x | y) & (~x | ~y); }  let x = 1, y = 2; console.log(findXor(x, y));

Output

Approach 2:

The idea is to use one of the properties of the XOR bitwise operator i.e. a + b = a^b + 2*(a & b), with the help of this we can do the same for an operator variant also.

C++14

// C++ program to find XOR without using ^ #include <iostream> using namespace std;  // Returns XOR of x and y int findXor(int x, int y) { 	return (x + y - (2 * (x & y))); }  int main() { 	int x = 1, y = 2; 	cout << findXor(x, y); 	return 0; }

Java

// Java program to find XOR without using ^ class GfG {          // Returns XOR of x and y     static int findXor(int x, int y) {         return (x + y - (2 * (x & y)));     }      public static void main(String[] args) {         int x = 1, y = 2;         System.out.println(findXor(x, y));     } }

Python

# Python program to find XOR without using ^  # Returns XOR of x and y def findXor(x, y):     return (x + y - (2 * (x & y)))  if __name__ == "__main__":     x, y = 1, 2     print(findXor(x, y))

// C# program to find XOR without using ^ using System;  class GfG {          // Returns XOR of x and y     static int findXor(int x, int y) {         return (x + y - (2 * (x & y)));     }      static void Main() {         int x = 1, y = 2;         Console.WriteLine(findXor(x, y));     } }

JavaScript

// JavaScript program to find XOR without using ^  // Returns XOR of x and y function findXor(x, y) {     return (x + y - (2 * (x & y))); }  let x = 1, y = 2; console.log(findXor(x, y));

Output

Approach 3:

The idea is to subtract the AND(&) of the two numbers from the OR(|) so that the common bit gets canceled and the opposite bits remain in the answer.

C++

// C++ program to find XOR without using ^ #include <iostream> using namespace std;  // Returns XOR of x and y int findXor(int x, int y) { 	return ((x | y) - (x & y)); }  int main() { 	int x = 1, y = 2; 	cout << findXor(x, y); 	return 0; }

Java

// Java program to find XOR without using ^ class GfG {          // Returns XOR of x and y     static int findXor(int x, int y) {         return ((x | y) - (x & y));     }      public static void main(String[] args) {         int x = 1, y = 2;         System.out.println(findXor(x, y));     } }

Python

# Python program to find XOR without using ^  # Returns XOR of x and y def findXor(x, y):     return ((x | y) - (x & y))  if __name__ == "__main__":     x, y = 1, 2     print(findXor(x, y))

// C# program to find XOR without using ^ using System;  class GfG {          // Returns XOR of x and y     static int findXor(int x, int y) {         return ((x | y) - (x & y));     }      static void Main() {         int x = 1, y = 2;         Console.WriteLine(findXor(x, y));     } }

JavaScript

// JavaScript program to find XOR without using ^  // Returns XOR of x and y function findXor(x, y) {     return ((x | y) - (x & y)); }  let x = 1, y = 2; console.log(findXor(x, y));