# Numbers formed by flipping common set bits in two given integers

Given two positive integers **A** and **B**, the task is to flip the common set bitsin **A** and **B**.

**Examples:**

Input:A = 7, B = 4Output:3 0Explanation:

The binary representation of 7 is 111

The binary representation of 4 is 100

Since the 3rd bit of both A and B is a set bit. Therefore, flipping the 3rd bit of A and B modifies A = 3 and B = 0

Therefore, the required output is 3 0

Input:A = 10, B = 20Output:10 20

**Naive Approach:** The simplest approach to solve this problem is to check if the **i ^{th}** bit of both

**A**and

**B**is a set or not. If found to be true, then flip the

**i**bit of both

^{th}**A**and

**B**. Finally, print the updated values of both

**A**and

**B**.

Below is the implementation of the above approach:

## C++

`// C++ program to implement` `// the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to flip bits of A and B` `// which are set bits in A and B` `void` `flipBitsOfAandB(` `int` `A, ` `int` `B)` `{` ` ` `// Iterater all possible bits` ` ` `// of A and B` ` ` `for` `(` `int` `i = 0; i < 32; i++) {` ` ` `// If ith bit is set in` ` ` `// both A and B` ` ` `if` `((A & (1 << i)) && (B & (1 << i))) {` ` ` `// Clear i-th bit of A` ` ` `A = A ^ (1 << i);` ` ` `// Clear i-th bit of B` ` ` `B = B ^ (1 << i);` ` ` `}` ` ` `}` ` ` `// Print A and B` ` ` `cout << A << ` `" "` `<< B;` `}` `// Driver Code` `int` `main()` `{` ` ` `int` `A = 7, B = 4;` ` ` `flipBitsOfAandB(A, B);` ` ` `return` `0;` `}` |

## Java

`// Java program to implement` `// the above approach` `import` `java.util.*;` ` ` `class` `GFG{` ` ` `// Function to flip bits of A and B` `// which are set bits in A and B` `static` `void` `flipBitsOfAandB(` `int` `A, ` `int` `B)` `{` ` ` ` ` `// Iterater all possible bits` ` ` `// of A and B` ` ` `for` `(` `int` `i = ` `0` `; i < ` `32` `; i++)` ` ` `{` ` ` ` ` `// If ith bit is set in` ` ` `// both A and B` ` ` `if` `(((A & (` `1` `<< i)) &` ` ` `(B & (` `1` `<< i))) != ` `0` `)` ` ` `{` ` ` ` ` `// Clear i-th bit of A` ` ` `A = A ^ (` `1` `<< i);` ` ` ` ` `// Clear i-th bit of B` ` ` `B = B ^ (` `1` `<< i);` ` ` `}` ` ` `}` ` ` ` ` `// Print A and B` ` ` `System.out.print(A + ` `" "` `+ B);` `}` ` ` `// Driver Code` `public` `static` `void` `main(String[] args)` `{` ` ` `int` `A = ` `7` `, B = ` `4` `;` ` ` ` ` `flipBitsOfAandB(A, B);` `}` `}` `// This code is contributed by code_hunt` |

## Python3

`# Python3 program to implement` `# the above approach` `# Function to flip bits of A and B` `# which are set in both of them` `def` `flipBitsOfAandB(A, B):` ` ` ` ` `# Iterate all possible bits of` ` ` `# A and B` ` ` `for` `i ` `in` `range` `(` `0` `, ` `32` `):` ` ` ` ` `# If ith bit is set in` ` ` `# both A and B` ` ` `if` `((A & (` `1` `<< i)) ` `and` ` ` `(B & (` `1` `<< i))):` ` ` ` ` `# Clear i-th bit of A` ` ` `A ` `=` `A ^ (` `1` `<< i)` ` ` `# Clear i-th bit of B` ` ` `B ` `=` `B ^ (` `1` `<< i)` ` ` ` ` `print` `(A, B)` `# Driver Code ` `if` `__name__ ` `=` `=` `"__main__"` `:` ` ` ` ` `A ` `=` `7` ` ` `B ` `=` `4` ` ` ` ` `flipBitsOfAandB(A, B)` ` ` `# This code is contributed by Virusbuddah_` |

## C#

`// C# program to implement` `// the above approach` `using` `System;` `class` `GFG{` `// Function to flip bits of A and B` `// which are set bits in A and B` `static` `void` `flipBitsOfAandB(` `int` `A, ` `int` `B)` `{` ` ` ` ` `// Iterater all possible bits` ` ` `// of A and B` ` ` `for` `(` `int` `i = 0; i < 32; i++)` ` ` `{` ` ` ` ` `// If ith bit is set in` ` ` `// both A and B` ` ` `if` `(((A & (1 << i)) &` ` ` `(B & (1 << i))) != 0)` ` ` `{` ` ` ` ` `// Clear i-th bit of A` ` ` `A = A ^ (1 << i);` ` ` `// Clear i-th bit of B` ` ` `B = B ^ (1 << i);` ` ` `}` ` ` `}` ` ` `// Print A and B` ` ` `Console.Write(A + ` `" "` `+ B);` `}` `// Driver Code` `public` `static` `void` `Main(` `string` `[] args)` `{` ` ` `int` `A = 7, B = 4;` ` ` `flipBitsOfAandB(A, B);` `}` `}` `// This code is contributed by chitranayal` |

## Javascript

`<script>` `// javascript program to implement` `// the above approach` `// Function to flip bits of A and B` `// which are set bits in A and B` `function` `flipBitsOfAandB(A , B)` `{` ` ` ` ` `// Iterater all possible bits` ` ` `// of A and B` ` ` `for` `(i = 0; i < 32; i++)` ` ` `{` ` ` ` ` `// If ith bit is set in` ` ` `// both A and B` ` ` `if` `(((A & (1 << i)) &` ` ` `(B & (1 << i))) != 0)` ` ` `{` ` ` ` ` `// Clear i-th bit of A` ` ` `A = A ^ (1 << i);` ` ` ` ` `// Clear i-th bit of B` ` ` `B = B ^ (1 << i);` ` ` `}` ` ` `}` ` ` ` ` `// Print A and B` ` ` `document.write(A + ` `" "` `+ B);` `}` ` ` `// Driver Code` `var` `A = 7, B = 4;` `flipBitsOfAandB(A, B);` `// This code is contributed by Princi Singh` `</script>` |

**Output:**

3 0

**Time Complexity:** O(32) * Auxiliary Space:* O(1)

**Efficient Approach:** To optimize the above approach, the idea is based on the following observations:

Find the bits which are set bits in both A and B using (A & B).

Clear the bits of A which are set bits in both A and B using A = (A ^ (A & B))

Cleat the bits of B which are set bits in both A and B using B = (B ^ (A & B))

Follow the steps below to solve the problem:

- Update
**A = (A ^ (A & B))**. - Update
**B = (B ^ (A & B))**. - Finally, print the updated values of
**A**and**B**.

Below is the implementation of the above approach:

## C++

`// C++ program to implement` `// the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to flip bits of A and B` `// which are set in both of them` `void` `flipBitsOfAandB(` `int` `A, ` `int` `B)` `{` ` ` `// Clear the bits of A which` ` ` `// are set in both A and B` ` ` `A = A ^ (A & B);` ` ` `// Clear the bits of B which` ` ` `// are set in both A and B` ` ` `B = B ^ (A & B);` ` ` `// Print updated A and B` ` ` `cout << A << ` `" "` `<< B;` `}` `// Driver Code` `int` `main()` `{` ` ` `int` `A = 10, B = 20;` ` ` `flipBitsOfAandB(A, B);` ` ` `return` `0;` `}` |

## Java

`// Java program to implement` `// the above approach` `import` `java.util.*;` ` ` `class` `GFG{` ` ` `// Function to flip bits of A and B` `// which are set in both of them` `static` `void` `flipBitsOfAandB(` `int` `A, ` `int` `B)` `{` ` ` ` ` `// Clear the bits of A which` ` ` `// are set in both A and B` ` ` `A = A ^ (A & B);` ` ` ` ` `// Clear the bits of B which` ` ` `// are set in both A and B` ` ` `B = B ^ (A & B);` ` ` ` ` `// Print updated A and B` ` ` `System.out.print(A + ` `" "` `+ B);` `}` ` ` `// Driver Code` `public` `static` `void` `main(String[] args)` `{` ` ` `int` `A = ` `10` `, B = ` `20` `;` ` ` ` ` `flipBitsOfAandB(A, B);` `}` `}` `// This code is contributed by sanjoy_62` |

## Python3

`# Python3 program to implement` `# the above approach` `# Function to flip bits of A and B` `# which are set in both of them` `def` `flipBitsOfAandB(A, B):` ` ` ` ` `# Clear the bits of A which` ` ` `# are set in both A and B` ` ` `A ` `=` `A ^ (A & B)` ` ` `# Clear the bits of B which` ` ` `# are set in both A and B` ` ` `B ` `=` `B ^ (A & B)` ` ` `# Print updated A and B` ` ` `print` `(A, B)` `# Driver Code ` `if` `__name__ ` `=` `=` `"__main__"` `:` ` ` ` ` `A ` `=` `10` ` ` `B ` `=` `20` ` ` ` ` `flipBitsOfAandB(A, B)` ` ` `# This code is contributed by Virusbuddah_` |

## C#

`// C# program to implement` `// the above approach` `using` `System;` `class` `GFG{` ` ` `// Function to flip bits of A and B` `// which are set in both of them` `static` `void` `flipBitsOfAandB(` `int` `A, ` `int` `B)` `{` ` ` ` ` `// Clear the bits of A which` ` ` `// are set in both A and B` ` ` `A = A ^ (A & B);` ` ` ` ` `// Clear the bits of B which` ` ` `// are set in both A and B` ` ` `B = B ^ (A & B);` ` ` ` ` `// Print updated A and B` ` ` `Console.Write(A + ` `" "` `+ B);` `}` ` ` `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` ` ` `int` `A = 10, B = 20;` ` ` ` ` `flipBitsOfAandB(A, B);` `}` `}` `// This code is contributed by Amit Katiyar` |

## Javascript

`<script>` `// javascript program to implement` `// the above approach` ` ` `// Function to flip bits of A and B` `// which are set in both of them` `function` `flipBitsOfAandB(A , B)` `{` ` ` ` ` `// Clear the bits of A which` ` ` `// are set in both A and B` ` ` `A = A ^ (A & B);` ` ` ` ` `// Clear the bits of B which` ` ` `// are set in both A and B` ` ` `B = B ^ (A & B);` ` ` ` ` `// Print updated A and B` ` ` `document.write(A + ` `" "` `+ B);` `}` ` ` `// Driver Code` `var` `A = 10, B = 20;` `flipBitsOfAandB(A, B);` `// This code contributed by shikhasingrajput` `</script>` |

**Output:**

10 20

* Time Complexity:* O(1)

*O(1)*

**Auxiliary Space:**Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend **live classes **with experts, please refer **DSA Live Classes for Working Professionals **and **Competitive Programming Live for Students**.