Minimum Bit Flips to Convert Number : When working with binary numbers in programming, you might encounter a problem where you need to find the minimum number of bit flips required to convert one number into another. This is a common interview and LeetCode problem that tests your understanding of bit manipulation.

In this guide, we’ll explain the concept step-by-step, walk through examples, and provide a LeetCode-style C++ solution.

What Does “Bit Flip” Mean?

A bit flip means changing a 0 to 1 or a 1 to 0 in a number’s binary representation.

Example:

Original bit: 0 → Flipped bit: 1
Original bit: 1 → Flipped bit: 0

If you have two integers, finding the minimum bit flips means determining the positions where the bits differ.

Minimum Bit Flips to Convert Number leetcode solution

Understanding the Problem

Problem Statement:
Given two integers start and goal, return the minimum number of bit flips required to convert start to goal.

Example

Input: start = 10, goal = 7
Binary of 10 → 1010
Binary of 7  → 0111

Comparing bit by bit:

1 0 1 0  
0 1 1 1  
↑ ↑   ↑  
Different bits at positions 1, 2, and 4 → 3 flips needed

Approach

Use XOR to identify different bits:
- XOR (^) returns 1 for differing bits, 0 for same bits.
Count set bits in the XOR result:
- The number of 1s = the number of bit flips needed.

Step-by-Step Example

For start = 29 and goal = 15:

XOR Operation: 29 (11101) 15 (01111) XOR → 10010
Count set bits in 10010:
There are 2 set bits → 2 flips needed.

1. C++ Solution

#include <iostream>
using namespace std;

int minBitFlips(int start, int goal) {
    int xorValue = start ^ goal; // Step 1: XOR to find differing bits
    int count = 0;
    while (xorValue > 0) {
        count += xorValue & 1;  // Step 2: Count set bits
        xorValue >>= 1;
    }
    return count;
}

int main() {
    int start = 10, goal = 7;
    cout << "Minimum Bit Flips: " << minBitFlips(start, goal) << endl;
    return 0;
}

✅ Shortcut in C++ (GCC/Clang):

return __builtin_popcount(start ^ goal);

2. C Solution for Minimum Bit Flips to Convert Number

#include <stdio.h>

int minBitFlips(int start, int goal) {
    int xorValue = start ^ goal; // XOR to find differing bits
    int count = 0;
    while (xorValue > 0) {
        count += xorValue & 1;  // Count set bits
        xorValue >>= 1;
    }
    return count;
}

int main() {
    int start = 10, goal = 7;
    printf("Minimum Bit Flips: %d\n", minBitFlips(start, goal));
    return 0;
}

3. Java Solution for Minimum Bit Flips to Convert Number

public class Main {
    public static int minBitFlips(int start, int goal) {
        int xorValue = start ^ goal; // XOR to find differing bits
        int count = 0;
        while (xorValue > 0) {
            count += xorValue & 1; // Count set bits
            xorValue >>= 1;
        }
        return count;
    }

    public static void main(String[] args) {
        int start = 10, goal = 7;
        System.out.println("Minimum Bit Flips: " + minBitFlips(start, goal));
    }
}

✅ Shortcut in Java (Java 8+):

return Integer.bitCount(start ^ goal);

4. Python Solution for Minimum Bit Flips to Convert Number

def min_bit_flips(start, goal):
    xor_value = start ^ goal  # XOR to find differing bits
    count = 0
    while xor_value > 0:
        count += xor_value & 1  # Count set bits
        xor_value >>= 1
    return count

# Example
start = 10
goal = 7
print("Minimum Bit Flips:", min_bit_flips(start, goal))

✅ Shortcut in Python:

return bin(start ^ goal).count('1')

Time Complexity for All Solutions

O(k), where k = number of bits in the integer.

Real-World Applications

Error Detection & Correction in data transmission.
Cryptography and data encoding.
Digital Circuit Design optimization.

Key Takeaways

Use XOR to detect differences in bits.
Count the number of 1s in the XOR result to get the flips.
This is a popular LeetCode problem for practicing bit manipulation.

FAQ for Minimum Bit Flips to Convert Number

Q1: Is this problem available on LeetCode?

Yes, it’s a well-known LeetCode problem often asked in coding interviews.

Q2: What’s the fastest approach?

The XOR + count set bits method is the fastest and most memory-efficient.

Q3: Can I solve this in one line in C++?

Yes, using __builtin_popcount(start ^ goal) in GCC/Clang.

Minimum Bit Flips to Convert Number | Master Beginner’s Guide with LeetCode Solution 2026