Number of Steps to Reduce a Number to Zero

Number of Steps to Reduce a Number to Zero - Problem

Imagine you have a magical number reducer that follows two simple rules:

If the number is even, divide it by 2
If the number is odd, subtract 1

Given an integer num, your task is to determine how many steps it takes to reduce this number all the way down to zero using these rules.

This problem combines basic mathematical operations with bit manipulation concepts, making it perfect for understanding how computers handle numbers at the binary level!

Example: Starting with 14:

14 → 7 → 6 → 3 → 2 → 1 → 0

That's 6 steps total!

Input & Output

example_1.py — Basic case

$ Input: num = 14

› Output: 6

💡 Note: Step 1) 14 is even; divide by 2 and obtain 7. Step 2) 7 is odd; subtract 1 and obtain 6. Step 3) 6 is even; divide by 2 and obtain 3. Step 4) 3 is odd; subtract 1 and obtain 2. Step 5) 2 is even; divide by 2 and obtain 1. Step 6) 1 is odd; subtract 1 and obtain 0.

example_2.py — Power of 2

$ Input: num = 8

› Output: 4

💡 Note: Step 1) 8 is even; divide by 2 and obtain 4. Step 2) 4 is even; divide by 2 and obtain 2. Step 3) 2 is even; divide by 2 and obtain 1. Step 4) 1 is odd; subtract 1 and obtain 0.

example_3.py — Edge case

$ Input: num = 1

› Output: 1

💡 Note: Step 1) 1 is odd; subtract 1 and obtain 0.

Constraints

0 ≤ num ≤ 10⁶
Important: The input will always be a non-negative integer

Visualization

Tap to expand

Understanding the Visualization

Start at the Peak

Begin with your number - this is your starting height on the mountain

Choose Your Move

If at an even position, take a giant leap (divide by 2). If at an odd position, take a small step (subtract 1)

Count Each Move

Every move counts as one step in your journey down the mountain

Reach the Valley

Continue until you reach zero - you've made it to the bottom!

Key Takeaway

🎯 Key Insight: Every number reduction follows a predictable pattern - even numbers let us make big jumps down the mountain, while odd numbers require small steps to get to the next even position.

Asked in

⊞ Microsoft 25 a Amazon 18 G Google 12 Apple 8

The simulation approach is the most intuitive solution with O(log n) time complexity. Simply follow the rules: divide even numbers by 2, subtract 1 from odd numbers, and count each step until reaching zero. For advanced optimization, bit manipulation can be used to count steps without simulation.

Common Approaches

Approach	Time	Space	Notes
✓ Simulation Approach	O(log n)	O(1)	Follow the rules step by step until we reach zero

Simulation Approach — Algorithm Steps

Start with the given number and initialize step counter to 0
While the number is not zero:
- If number is even, divide by 2
- If number is odd, subtract 1
- Increment step counter
Return the total number of steps

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with 14

14 is even, so divide by 2 → 7

Now have 7

7 is odd, so subtract 1 → 6

Now have 6

6 is even, so divide by 2 → 3

Now have 3

3 is odd, so subtract 1 → 2

Now have 2

2 is even, so divide by 2 → 1

Now have 1

1 is odd, so subtract 1 → 0

Code -

solution.c — C

#include <stdio.h>

int numberOfSteps(int num) {
    int steps = 0;
    while (num > 0) {
        if (num % 2 == 0) {
            num /= 2;
        } else {
            num -= 1;
        }
        steps++;
    }
    return steps;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Each operation roughly halves the number, so we need logarithmic steps

⚡ Linearithmic

Space Complexity

O(1)

We only need a constant amount of extra space for counting

✓ Linear Space

67.0K Views

Medium Frequency

~8 min Avg. Time

2.1K 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

Simulation Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler