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 = 3Output:1Explanation:

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 = 5Output: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
**i**bit of^{th}**C**is not set, then check for the following:- If the
**i**bit of^{th}**A**is set, increment**res**with**1**,**i**bit of^{th}**A**needs to be flipped. - If the
**i**bit of^{th}**B**is set, increment**res**with**1**,**i**bit of^{th}**B**needs to be flipped.

- If the
- If the
**i**bit of^{th}**C**is set, then check for the following:- If the
**i**bit of both^{th}**A**and**B**are not set, increment**res**with**1**, either of the bit needs to be flipped. - If the
**i**bit of both^{th}**A**and**B**are set, we do not have to flip any of the bits.

- If the

- If the
- 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 <bits/stdc++.h>` `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

`<script>` `// javascript 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` ` ` `function` `minimumFlips(A , B , C) {` ` ` `// Stores the count of flipped bit` ` ` `var` `res = 0;` ` ` `// Iterate over the range [0, 32]` ` ` `for` `(i = 0; i < 32; i++) {` ` ` `var` `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` ` ` `var` `A = 2, B = 6, C = 5;` ` ` `document.write(minimumFlips(A, B, C));` `// This code is contributed by aashish1995` `</script>` |

**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****.**