# Count minimum bits to flip such that XOR of A and B equal to C

Given a sequence of three binary sequences A, B and C of N bits. Count the minimum bits required to flip in A and B such that XOR of A and B is equal to C. For example:-

```Input: N = 3
A = 110
B = 101
C = 001
Output: 1
We only need to flip the bit of 2nd position
of either A or B, such that A ^ B = C i.e.,
100 ^ 101 = 001
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

A Naive approach is to generate all possible combination of bits in A and B and then XORing them to Check whether it is equal to C or not. Time complexity of this approach grows exponentially so it would not be better for large value of N.

An Efficient approach is to use concept of XOR.

```XOR Truth Table
Input    Output
X     Y     Z
0     0  -  0
0     1  -  1
1     0  -  1
1     1  -  0
```

If we generalize, we will find that at any position of A and B, we just only need to flip ith (0 to N-1) position of either A or B otherwise we will not able to achieve minimum no of Bits.
So at any position of i (0 to N-1) you will encounter two type of situation i.e., either A[i] == B[i] or A[i] != B[i]. Let’s discuss it one by one.

• If A[i] == B[i] then XOR of these bits will be 0, two cases arise in C[]: C[i]==0 or C[i]==1.
If C[i] == 0, then no need to flip the bit but if C[i] == 1 then we have to flip the bit either in A[i] or B[i] so that 1^0 == 1 or 0^1 == 1.
• If A[i] != B[i] then XOR of these Bits gives a 1, In C two cases again arise i.e., either C[i] == 0 or C[i] == 1.
Therefore if C[i] == 1, then we need not to flip the bit but if C[i] == 0, then we need to flip the bit either in A[i] or B[i] so that 0^0==0 or 1^1==0

## C++

```// C++ code to count the Minimum bits in A and B
#include<bits/stdc++.h>
using namespace std;

int totalFlips(char *A, char *B, char *C, int N)
{
int count = 0;
for (int i=0; i < N; ++i)
{
// If both A[i] and B[i] are equal
if (A[i] == B[i] && C[i] == '1')
++count;

// If Both A and B are unequal
else if (A[i] != B[i] && C[i] == '0')
++count;
}
return count;
}

//Driver Code
int main()
{
//N represent total count of Bits
int N = 5;
char a[] = "10100";
char b[] = "00010";
char c[] = "10011";

cout << totalFlips(a, b, c, N);

return 0;
}
```

## Python

```# Python code to find minimum bits to be flip
def totalFlips(A, B, C, N):

count = 0
for i in range(N):

# If both A[i] and B[i] are equal
if A[i] == B[i] and C[i] == '1':
count=count+1

# if A[i] and B[i] are unequal
elif A[i] != B[i] and C[i] == '0':
count=count+1
return count

# Driver Code
# N represent total count of Bits
N = 5
a = "10100"
b = "00010"
c = "10011"
print(totalFlips(a, b, c, N))
```
```Output:
2
```

Time Complexity: O(N)
Auxiliary space: O(1)

This article is contributed by Shubham Bansal. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

# GATE CS Corner    Company Wise Coding Practice

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.
1.5 Average Difficulty : 1.5/5.0
Based on 6 vote(s)