Related Articles
Minimum number of bits required to be flipped such that Bitwise OR of A and B is equal to C
• Difficulty Level : Medium
• Last Updated : 06 May, 2021

Given three positives integers A, B, and C, the task is to count the minimum number of flipping of bits required in A and B, such that the Bitwise OR of A and B is equal to C or not.

Examples:

Input: A = 2, B = 2, C = 3
Output: 1
Explanation:
The binary representation of A is 010, B is 010 and C is 011.
Flip the 3rd bit of either A or B, such that A | B = C, i.e. 011 | 010 = 011.
Therefore, the total number of flips required is 1.

Input: A = 2, B = 6, C = 5
Output: 3

Approach: Follow the steps below to solve the problem:

• Initialize a variable, say res, that stores the minimum number of the flipped bits required.
• Iterate over each bit of A, B, and C and perform the following steps:
• If the ith bit of C is not set, then check for the following:
• If the ith bit of  A is set, increment res with 1, ith bit of A needs to be flipped.
• If the ith bit of  B is set, increment res with 1,  ith bit of B needs to be flipped.
• If the ith bit of C is set, then check for the following:
• If the ith bit of both A and B are not set, increment res with 1, either of the bit needs to be flipped.
• If the ith bit of both A and B are set, we do not have to flip any of the bits.
• After completing the above steps, print the value of res as the result.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach`   `#include ` `using` `namespace` `std;`   `// Function to count the number of` `// bit flips required on A and B` `// such that Bitwise OR of A and B is C` `int` `minimumFlips(``int` `A, ``int` `B, ``int` `C)` `{` `    ``// Stores the count of flipped bit` `    ``int` `res = 0;`   `    ``// Iterate over the range [0, 32]` `    ``for` `(``int` `i = 0; i < 32; i++) {`   `        ``int` `x = 0, y = 0, z = 0;`   `        ``// Check if i-th bit of A is set` `        ``if` `(A & (1 << i)) {` `            ``x = 1;` `        ``}`   `        ``// Check if i-th bit of B is` `        ``// set or not` `        ``if` `(B & (1 << i)) {` `            ``y = 1;` `        ``}`   `        ``// Check if i-th bit of C is` `        ``// set or not` `        ``if` `(C & (1 << i)) {` `            ``z = 1;` `        ``}`   `        ``// If i-th bit of C is unset` `        ``if` `(z == 0) {`   `            ``// Check if i-th bit of` `            ``// A is set or not` `            ``if` `(x) {` `                ``res++;` `            ``}`   `            ``// Check if i-th bit of` `            ``// B is set or not` `            ``if` `(y) {` `                ``res++;` `            ``}` `        ``}`   `        ``// Check if i-th bit of C` `        ``// is set or not` `        ``if` `(z == 1) {`   `            ``// Check if i-th bit of` `            ``// both A and B is set` `            ``if` `(x == 0 && y == 0) {` `                ``res++;` `            ``}` `        ``}` `    ``}`   `    ``// Return the count` `    ``// of bits flipped` `    ``return` `res;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `A = 2, B = 6, C = 5;` `    ``cout << minimumFlips(A, B, C);`   `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `import` `java.io.*;` `import` `java.lang.*;` `import` `java.util.*;`   `class` `GFG{`   `// Function to count the number of` `// bit flips required on A and B` `// such that Bitwise OR of A and B is C` `static` `int` `minimumFlips(``int` `A, ``int` `B, ``int` `C)` `{` `    `  `    ``// Stores the count of flipped bit` `    ``int` `res = ``0``;`   `    ``// Iterate over the range [0, 32]` `    ``for``(``int` `i = ``0``; i < ``32``; i++) ` `    ``{` `        ``int` `x = ``0``, y = ``0``, z = ``0``;`   `        ``// Check if i-th bit of A is set` `        ``if` `((A & (``1` `<< i)) != ``0``)` `        ``{` `            ``x = ``1``;` `        ``}`   `        ``// Check if i-th bit of B is` `        ``// set or not` `        ``if` `((B & (``1` `<< i)) != ``0``)` `        ``{` `            ``y = ``1``;` `        ``}`   `        ``// Check if i-th bit of C is` `        ``// set or not` `        ``if` `((C & (``1` `<< i)) != ``0``)` `        ``{` `            ``z = ``1``;` `        ``}`   `        ``// If i-th bit of C is unset` `        ``if` `(z == ``0``) ` `        ``{`   `            ``// Check if i-th bit of` `            ``// A is set or not` `            ``if` `(x == ``1``) ` `            ``{` `                ``res++;` `            ``}`   `            ``// Check if i-th bit of` `            ``// B is set or not` `            ``if` `(y == ``1``) ` `            ``{` `                ``res++;` `            ``}` `        ``}`   `        ``// Check if i-th bit of C` `        ``// is set or not` `        ``if` `(z == ``1``) ` `        ``{`   `            ``// Check if i-th bit of` `            ``// both A and B is set` `            ``if` `(x == ``0` `&& y == ``0``) ` `            ``{` `                ``res++;` `            ``}` `        ``}` `    ``}`   `    ``// Return the count` `    ``// of bits flipped` `    ``return` `res;` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``int` `A = ``2``, B = ``6``, C = ``5``;` `    `  `    ``System.out.println(minimumFlips(A, B, C));` `}` `}`   `// This code is contributed by Kingash`

## Python3

 `# Python3 program for the above approach`   `# Function to count the number of` `# bit flips required on A and B` `# such that Bitwise OR of A and B is C` `def` `minimumFlips(A, B, C):` `    `  `    ``# Stores the count of flipped bit` `    ``res ``=` `0`   `    ``# Iterate over the range [0, 32]` `    ``for` `i ``in` `range``(``32``):` `        ``x, y, z ``=` `0``, ``0``, ``0`   `        ``# Check if i-th bit of A is set` `        ``if` `(A & (``1` `<< i)):` `            ``x ``=` `1`   `        ``# Check if i-th bit of B is` `        ``# set or not` `        ``if` `(B & (``1` `<< i)):` `            ``y ``=` `1`   `        ``# Check if i-th bit of C is` `        ``# set or not` `        ``if` `(C & (``1` `<< i)):` `            ``z ``=` `1`   `        ``# If i-th bit of C is unset` `        ``if` `(z ``=``=` `0``):` `            `  `            ``# Check if i-th bit of` `            ``# A is set or not` `            ``if` `(x):` `                ``res ``+``=` `1`   `            ``# Check if i-th bit of` `            ``# B is set or not` `            ``if` `(y):` `                ``res ``+``=` `1`   `        ``# Check if i-th bit of C` `        ``# is set or not` `        ``if` `(z ``=``=` `1``):` `            `  `            ``# Check if i-th bit of` `            ``# both A and B is set` `            ``if` `(x ``=``=` `0` `and` `y ``=``=` `0``):` `                ``res ``+``=` `1`   `    ``# Return the count` `    ``# of bits flipped` `    ``return` `res`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    `  `    ``A, B, C ``=` `2``, ``6``, ``5` `    `  `    ``print``(minimumFlips(A, B, C))`   `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the above approach` `using` `System;`   `class` `GFG {`   `    ``// Function to count the number of` `    ``// bit flips required on A and B` `    ``// such that Bitwise OR of A and B is C` `    ``static` `int` `minimumFlips(``int` `A, ``int` `B, ``int` `C)` `    ``{`   `        ``// Stores the count of flipped bit` `        ``int` `res = 0;`   `        ``// Iterate over the range [0, 32]` `        ``for` `(``int` `i = 0; i < 32; i++) {` `            ``int` `x = 0, y = 0, z = 0;`   `            ``// Check if i-th bit of A is set` `            ``if` `((A & (1 << i)) != 0) {` `                ``x = 1;` `            ``}`   `            ``// Check if i-th bit of B is` `            ``// set or not` `            ``if` `((B & (1 << i)) != 0) {` `                ``y = 1;` `            ``}`   `            ``// Check if i-th bit of C is` `            ``// set or not` `            ``if` `((C & (1 << i)) != 0) {` `                ``z = 1;` `            ``}`   `            ``// If i-th bit of C is unset` `            ``if` `(z == 0) {`   `                ``// Check if i-th bit of` `                ``// A is set or not` `                ``if` `(x == 1) {` `                    ``res++;` `                ``}`   `                ``// Check if i-th bit of` `                ``// B is set or not` `                ``if` `(y == 1) {` `                    ``res++;` `                ``}` `            ``}`   `            ``// Check if i-th bit of C` `            ``// is set or not` `            ``if` `(z == 1) {`   `                ``// Check if i-th bit of` `                ``// both A and B is set` `                ``if` `(x == 0 && y == 0) {` `                    ``res++;` `                ``}` `            ``}` `        ``}`   `        ``// Return the count` `        ``// of bits flipped` `        ``return` `res;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main(``string``[] args)` `    ``{` `        ``int` `A = 2, B = 6, C = 5;`   `        ``Console.WriteLine(minimumFlips(A, B, C));` `    ``}` `}`   `// This code is contributed by ukasp.`

## Javascript

 ``

Output:

`3`

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

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up
Recommended Articles
Page :