Minimum Flips to Make a OR b Equal to c - Practice Coding Problems

Minimum Flips to Make a OR b Equal to c - Problem

Bit Manipulation Medium

Given three positive integers a, b, and c, find the minimum number of bit flips required to make the bitwise OR of a and b equal to c.

A flip operation consists of changing a single bit from 1 to 0 or from 0 to 1 in the binary representation of either a or b.

Goal: Transform a and b such that (a OR b) == c using the fewest possible bit flips.

Example: If a = 2 (binary: 10), b = 6 (binary: 110), and c = 5 (binary: 101), then a OR b = 110 (which is 6). To make it equal 5 (binary: 101), we need to flip specific bits in a or b.

Input & Output

example_1.py — Basic Case

$ Input: a = 2, b = 6, c = 5

› Output: 3

💡 Note: a = 2 (010), b = 6 (110), c = 5 (101). Currently a OR b = 110 (6). To get 101 (5): Position 0: need 1, have 0 → flip 1 bit. Position 1: need 0, have 1 (both a,b are 1) → flip 2 bits. Position 2: need 1, have 1 → no flips. Total: 1 + 2 + 0 = 3 flips.

example_2.py — No Flips Needed

$ Input: a = 4, b = 2, c = 6

› Output: 0

💡 Note: a = 4 (100), b = 2 (010), c = 6 (110). Currently a OR b = 110 (6), which equals c = 6. No flips needed.

example_3.py — Single Bit Numbers

$ Input: a = 1, b = 2, c = 3

› Output: 0

💡 Note: a = 1 (01), b = 2 (10), c = 3 (11). Currently a OR b = 11 (3), which equals c = 3. No flips needed.

Visualization

Tap to expand

Understanding the Visualization

Setup

You have two control panels (a and b) and a target pattern (c)

OR Logic

Each light is ON if either switch A OR switch B is ON for that position

Compare

Check each light position: does current state match target?

Flip Strategy

If target is ON but current is OFF: flip one switch. If target is OFF but current is ON: flip all ON switches

Sum

Count total switch flips across all positions

Key Takeaway

🎯 Key Insight: Each bit position can be analyzed independently. The minimum flips for each position depends on the current OR result and target bit: flip one bit to turn ON a position, flip all ON bits to turn OFF a position.

Time & Space Complexity

Time Complexity

⏱️

O(log max(a,b,c))

We iterate through each bit position, and the maximum number of bits is log of the largest number

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for bit manipulation operations

✓ Linear Space

Constraints

1 ≤ a, b, c ≤ 10⁹
All numbers are positive integers
The maximum number of bits to consider is 32 (since numbers ≤ 10⁹)

Asked in

a Amazon 15 ⊞ Microsoft 12 G Google 8 f Meta 5

The optimal solution uses bit manipulation to analyze each bit position independently. For each bit, we determine the minimum flips needed based on the OR operation rules: if the target bit is 1 but current OR is 0, flip one bit; if target is 0 but current OR is 1, flip all set bits. Time complexity: O(log n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Bit-by-Bit Analysis (Optimal)	O(log max(a,b,c))	O(1)	Analyze each bit position independently to determine minimum flips needed
Brute Force (Try All Combinations)	O(2^n)	O(1)	Try all possible combinations of bit flips until finding the minimum

Bit-by-Bit Analysis (Optimal) — Algorithm Steps

Iterate through each bit position from least significant to most significant
For each position i, extract bits: bit_a = (a >> i) & 1, bit_b = (b >> i) & 1, bit_c = (c >> i) & 1
Calculate current OR result: current_or = bit_a | bit_b
If current_or == bit_c, no flips needed for this position
If bit_c == 1 and current_or == 0, need 1 flip (either a or b)
If bit_c == 0 and current_or == 1, need flips based on how many bits are set
Sum up all flips needed across all bit positions

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Bits

Get the least significant bit of a, b, and c

Calculate OR

Compute current OR result for this bit position

Compare

Check if current OR matches desired bit in c

Count Flips

Determine minimum flips needed for this position

Shift

Move to next bit position and repeat

Code -

solution.c — C

#include <stdio.h>

int minFlips(int a, int b, int c) {
    int flips = 0;
    
    // Process each bit position
    while (a > 0 || b > 0 || c > 0) {
        // Get the least significant bit of each number
        int bitA = a & 1;
        int bitB = b & 1;
        int bitC = c & 1;
        
        // Current OR result for this bit position
        int currentOr = bitA | bitB;
        
        if (currentOr != bitC) {
            if (bitC == 1) {
                // Need c to be 1, but current OR is 0
                // This means both a and b are 0, so flip one of them
                flips += 1;
            } else {
                // Need c to be 0, but current OR is 1
                // Need to flip all bits that are 1
                flips += bitA + bitB;
            }
        }
        
        // Move to next bit position
        a >>= 1;
        b >>= 1;
        c >>= 1;
    }
    
    return flips;
}

int main() {
    int a, b, c;
    scanf("%d %d %d", &a, &b, &c);
    printf("%d\n", minFlips(a, b, c));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log max(a,b,c))

We iterate through each bit position, and the maximum number of bits is log of the largest number

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for bit manipulation operations

✓ Linear Space

Constraints

1 ≤ a, b, c ≤ 10⁹
All numbers are positive integers
The maximum number of bits to consider is 32 (since numbers ≤ 10⁹)

23.6K Views

Medium Frequency

~15 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Bit-by-Bit Analysis (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler