Reach a Number - Practice Coding Problems

Reach a Number - Problem

Imagine you're standing at position 0 on an infinite number line, and you need to reach a specific target position. Here's the twist: on your i-th move, you must take exactly i steps, but you can choose to go either left or right.

For example, on move 1 you take 1 step, on move 2 you take 2 steps, on move 3 you take 3 steps, and so on. Your goal is to find the minimum number of moves required to reach the target position.

Example: To reach target = 3, you could go right 1 step (position 1), then right 2 steps (position 3). That's 2 moves total.

Input & Output

example_1.py — Basic Case

$ Input: target = 2

› Output: 3

💡 Note: On the 1st move we step from 0 to 1. On the 2nd move we step from 1 to -1. On the 3rd move we step from -1 to 2. So we need 3 moves total: Right 1, Left 2, Right 3 → positions: 1, -1, 2

example_2.py — Perfect Match

$ Input: target = 3

› Output: 2

💡 Note: On the 1st move we step from 0 to 1. On the 2nd move we step from 1 to 3. Total sum 1+2=3 equals target, so we reach it in 2 moves: Right 1, Right 2 → positions: 1, 3

example_3.py — Negative Target

$ Input: target = -2

› Output: 3

💡 Note: Due to symmetry, reaching -2 requires the same number of moves as reaching +2. We can go Left 1, Right 2, Left 3 → positions: -1, 1, -2

Constraints

-10⁹ ≤ target ≤ 10⁹
target ≠ 0
Time limit: 1 second per test case

Visualization

Tap to expand

Understanding the Visualization

Keep going right

Move right with increasing step sizes until you reach or pass the target

Check overshoot

If you overshot by an even amount, you can flip one previous move

Adjust if needed

If overshoot is odd, take 1-2 more steps until it becomes even

Key Takeaway

🎯 Key Insight: Mathematics beats brute force! Instead of trying all 2^n paths, we use the fact that overshooting by an even amount always allows a perfect adjustment.

Asked in

G Google 42 ⊞ Microsoft 35 a Amazon 28 f Meta 22

The optimal mathematical approach works by moving right until we overshoot the target, then adjusting. Key insight: if we overshoot by an even amount, we can flip one previous move to reach exactly. If the overshoot is odd, we need 1-2 more moves until the difference becomes even. Time complexity: O(√n).

Common Approaches

Approach	Time	Space	Notes
✓ Mathematical Approach (Optimal)	O(√n)	O(1)	Use mathematical insights to find the minimum moves in O(√n) time
Brute Force (Try All Combinations)	O(2^n)	O(n)	Try every possible combination of left/right moves using recursion

Mathematical Approach (Optimal) — Algorithm Steps

Work with absolute value of target (symmetry)
Keep adding steps (1+2+3+...) until sum ≥ target
If sum equals target, we're done
If sum > target by even amount, flip one move to reach target exactly
If sum > target by odd amount, continue until difference is even

Visualization

Tap to expand

Step-by-Step Walkthrough

Move right until overshoot

Keep adding 1+2+3+... until sum ≥ target

Check the difference

Calculate how much we overshot the target

Adjust if needed

If difference is even, flip one move. If odd, continue until even.

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int reachNumber(int target) {
    if (target < 0) target = -target;
    
    int step = 0;
    int sumSteps = 0;
    
    // Keep moving right until we reach or overshoot target
    while (sumSteps < target) {
        step++;
        sumSteps += step;
    }
    
    // If we hit target exactly, return number of steps
    if (sumSteps == target) {
        return step;
    }
    
    // We overshot. Calculate the difference
    int diff = sumSteps - target;
    
    // If difference is even, we can flip one move to reach target
    if (diff % 2 == 0) {
        return step;
    }
    
    // If difference is odd, we need more steps until difference becomes even
    step++;
    sumSteps += step;
    diff = sumSteps - target;
    
    if (diff % 2 == 0) {
        return step;
    } else {
        return step + 1;
    }
}

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

Time & Space Complexity

Time Complexity

⏱️

O(√n)

We need approximately √(2n) steps to reach sum ≥ n, since 1+2+...+k = k(k+1)/2

✓ Linear Growth

Space Complexity

O(1)

Only uses a few integer variables regardless of input size

✓ Linear Space

58.4K Views

Medium Frequency

~25 min Avg. Time

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

Mathematical Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler