Minimum One Bit Operations to Make Integers Zero

Minimum One Bit Operations to Make Integers Zero - Problem

Given an integer n, you must transform it into 0 using the following operations any number of times:

Change the rightmost (0th) bit in the binary representation of n.
Change the ith bit in the binary representation of n if the (i-1)th bit is set to 1 and the (i-2)th through 0th bits are set to 0.

Return the minimum number of operations to transform n into 0.

Input & Output

Example 1 — Basic Case

$ Input: n = 3

› Output: 2

💡 Note: Binary 3 = 11. First operation: change rightmost bit → 10 (2). Second operation: change bit 1 since bit 0 is 0 → 00 (0). Total: 2 operations.

Example 2 — Single Bit

$ Input: n = 6

› Output: 4

💡 Note: Binary 6 = 110. Following the Gray code pattern: f(6) = 6 ⊕ f(3) = 6 ⊕ 2 = 110 ⊕ 010 = 100 = 4 operations.

Example 3 — Edge Case Zero

$ Input: n = 0

› Output: 0

💡 Note: Already at target 0, no operations needed.

Constraints

0 ≤ n ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 35 f Facebook 28 M Microsoft 22

The key insight is recognizing this follows the Gray code pattern where each number maps to its position in the inverse Gray code sequence. The optimal approach uses the mathematical formula f(n) = n ⊕ f(n>>1) achieving O(log n) time complexity.

Common Approaches

✓ Gray Code Pattern Recognition

⏱️ Time: O(log n) Space: O(log n)

The problem follows the Gray code pattern where f(n) = n ⊕ f(n>>1). This is because the operations correspond to moving through Gray code sequence in reverse.

Memoized Recursion

⏱️ Time: O(n) Space: O(n)

Same recursive approach but store results in a hash map to avoid recalculating the same subproblems. This dramatically reduces time complexity by eliminating duplicate work.

Recursive Brute Force

⏱️ Time: O(2ⁿ) Space: O(n)

For each number, try both possible operations (flip rightmost bit, or flip any valid bit where conditions are met) and recursively solve subproblems. Take minimum of all paths.

Gray Code Pattern Recognition — Algorithm Steps

Recognize pattern: this is inverse Gray code
Use formula f(n) = n ⊕ f(n>>1)
Base case: f(0) = 0
Recursively apply formula with bit shifts

Visualization

Tap to expand

Step-by-Step Walkthrough

Pattern

Recognize Gray code inverse relationship

Formula

Apply f(n) = n ⊕ f(n>>1) recursively

Result

Compute answer in O(log n) time

Code -

solution.c — C

#include <stdio.h>

int solution(int n) {
    if (n == 0) return 0;
    return n ^ solution(n >> 1);
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%d\n", solution(n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Each recursive call reduces n by half through right shift, so depth is logarithmic

✓ Linear Growth

Space Complexity

O(log n)

Recursion stack depth is proportional to number of bits in n

⚡ Linearithmic Space

32.4K Views

Medium Frequency

~35 min Avg. Time

847 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

Constraints

Visualization

Related Problems

Common Approaches

Gray Code Pattern Recognition — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler