Reach a Number

Reach a Number - Problem

You are standing at position 0 on an infinite number line. There is a destination at position target.

You can make some number of moves numMoves so that:

On each move, you can either go left or right.
During the i^th move (starting from i == 1 to i == numMoves), you take i steps in the chosen direction.

Given the integer target, return the minimum number of moves required (i.e., the minimum numMoves) to reach the destination.

Input & Output

Example 1 — Basic Case

$ Input: target = 3

› Output: 2

💡 Note: Move 1: go right 1 step (position = 1). Move 2: go right 2 steps (position = 3). Total: 2 moves to reach target 3.

Example 2 — Requires Backtracking

$ Input: target = 2

› Output: 3

💡 Note: Move 1: go right 1 step (position = 1). Move 2: go right 2 steps (position = 3). Move 3: go left 3 steps (position = 0). But we can do better: Move 1: go right 1 step, Move 2: go left 2 steps (position = -1), Move 3: go right 3 steps (position = 2). Total: 3 moves.

Example 3 — Negative Target

$ Input: target = -2

› Output: 3

💡 Note: Same as target = 2 due to symmetry. We can reach -2 by going left instead of right in the same number of moves.

Constraints

-10⁹ ≤ target ≤ 10⁹
target ≠ 0

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 18 a Amazon 12

The key insight is recognizing that we can flip any rightward move to leftward by changing its sign. The optimal approach uses mathematical analysis: find the minimum moves where the sum equals or exceeds the target, then check if we can adjust by flipping moves. Time: O(√n), Space: O(1)

Common Approaches

✓ Brute Force Simulation

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

For each move, recursively try both left and right directions. Track the minimum moves needed to reach the target across all possible paths.

Mathematical Approach

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

Calculate the sum of moves until it exceeds target, then determine if we can adjust by flipping moves from right to left to reach exactly the target.

Brute Force Simulation — Algorithm Steps

Start at position 0 with move number 1
For each move, try both left (-i) and right (+i)
Recursively explore until target is reached
Return minimum moves among all successful paths

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin at position 0, first move is size 1

Branch

For each move, try both left and right directions

Explore

Recursively continue until target is reached

Code -

solution.c — C

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

int abs_val(int x) {
    return x < 0 ? -x : x;
}

int min(int a, int b) {
    return a < b ? a : b;
}

int dfs(int pos, int move, int target) {
    if (pos == target) {
        return 0;
    }
    if (move > abs_val(target) + 10) { // Pruning
        return INT_MAX;
    }
    
    // Try right (+move)
    int right = dfs(pos + move, move + 1, target);
    // Try left (-move)
    int left = dfs(pos - move, move + 1, target);
    
    if (right == INT_MAX && left == INT_MAX) {
        return INT_MAX;
    }
    
    return 1 + min(right, left);
}

int solution(int target) {
    return dfs(0, 1, target);
}

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

Time & Space Complexity

Time Complexity

⏱️

O(2ⁿ)

Each move has 2 choices (left/right), creating 2^n possible paths

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth proportional to number of moves

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~25 min Avg. Time

850 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

Brute Force Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler