Minimum Operations to Reduce an Integer to 0

Minimum Operations to Reduce an Integer to 0 - Problem

You are given a positive integer n, you can do the following operation any number of times:

Add or subtract a power of 2 from n.

Return the minimum number of operations to make n equal to 0.

A number x is power of 2 if x == 2ⁱ where i >= 0.

Input & Output

Example 1 — Medium Number

$ Input: n = 39

› Output: 3

💡 Note: 39 in binary is 100111. We can do: 39 + 1 = 40 (1 op), 40 - 8 = 32 (2 ops), 32 - 32 = 0 (3 ops). Total: 3 operations.

Example 2 — Power of 2

$ Input: n = 8

› Output: 1

💡 Note: 8 is a power of 2 (2³), so we can subtract 8 directly: 8 - 8 = 0. Only 1 operation needed.

Example 3 — Small Number

$ Input: n = 3

› Output: 2

💡 Note: 3 in binary is 11. We can do: 3 + 1 = 4 (1 op), then 4 - 4 = 0 (2 ops). Or: 3 - 2 = 1 (1 op), 1 - 1 = 0 (2 ops). Both take 2 operations.

Constraints

1 ≤ n ≤ 10⁶

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 18 a Amazon 15

The key insight is to use bit manipulation: consecutive 1s in binary representation should be handled by adding the next power of 2 (carry-over) rather than subtracting each individual bit. Best approach is greedy bit manipulation with Time: O(log n), Space: O(1).

Common Approaches

✓ Bit Manipulation (Greedy)

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

Convert the problem to binary representation. Each isolated 1-bit requires one operation. Consecutive 1s can be handled more efficiently by 'carrying over' - it's better to add a power of 2 to create a single 1 at higher position than subtract multiple powers.

Brute Force BFS

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

Try all possible additions and subtractions of powers of 2 from the current number. Use BFS to find the minimum number of operations by exploring all states level by level.

Memoization (Top-Down DP)

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

Use recursion to try all possible operations (add/subtract powers of 2) and memoize results to avoid redundant calculations. For each number, try all reasonable powers of 2 and take the minimum.

Bit Manipulation (Greedy) — Algorithm Steps

Convert n to binary representation
Process bits from right to left
For isolated 1s: subtract that power of 2
For consecutive 1s: add next power of 2 and carry over

Visualization

Tap to expand

Step-by-Step Walkthrough

Binary

Convert 39 to binary: 100111

Process

Handle consecutive 1s by adding 1 (carry-over)

Result

Count total operations needed

Code -

solution.c — C

#include <stdio.h>

int solution(int n) {
    int operations = 0;
    
    while (n > 0) {
        if ((n & 1) == 0) {  // Current bit is 0
            n >>= 1;
        } else if ((n & 3) == 1) {  // Current bit is 1, next bit is 0
            operations++;
            n >>= 1;
        } else {  // Current bit is 1, next bit is 1 (consecutive 1s)
            operations++;
            n += 1;  // Carry over
        }
    }
    
    return operations;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Process each bit position once, and there are log n bits

⚡ Linearithmic

Space Complexity

O(1)

Only use constant extra variables

✓ Linear Space

23.5K Views

Medium Frequency

~15 min Avg. Time

890 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

Bit Manipulation (Greedy) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler