Codestin Search App

Jump Game - Problem

Jump Game - Can You Reach the Destination?

Imagine you're playing a board game where you start at the first position and need to reach the last position to win. At each position, you have a number that tells you the maximum distance you can jump forward.

Given an integer array nums where you start at index 0, each element nums[i] represents your maximum jump length from that position. Your goal is to determine if you can reach the last index.

Key Points:

You start at index 0
From position i, you can jump anywhere from 1 to nums[i] steps forward
Return true if you can reach the last index, false otherwise

Example: [2,3,1,1,4] → You can jump from index 0 to 1, then to 4 (the last index), so return true.

Input & Output

example_1.py — Basic Success Case

$ Input: nums = [2,3,1,1,4]

› Output: true

💡 Note: Jump 1 step from index 0 to 1, then 3 steps to the last index (4). Multiple valid paths exist: 0→1→4 or 0→2→3→4.

example_2.py — Blocked Path

$ Input: nums = [3,2,1,0,4]

› Output: false

💡 Note: You will always arrive at index 3. The maximum jump from there is 0, so you cannot reach the last index (4).

example_3.py — Single Element

$ Input: nums = [0]

› Output: true

💡 Note: You start at the last index (0), so you're already at the destination.

Visualization

Tap to expand

Understanding the Visualization

Start at first island

Begin your journey at island 0 with a certain bridge capacity

Track maximum reach

Keep track of the furthest island you can possibly reach

Extend your range

At each island, update your maximum reach based on available bridges

Check if blocked

If you reach an island beyond your capacity, you're stranded

Key Takeaway

🎯 Key Insight: Like a smart island explorer, you don't need to try every possible route. Just keep track of how far you can reach and ensure you're never stranded on an unreachable island!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, checking each position once

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track furthest reachable position

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁴
0 ≤ nums[i] ≤ 10⁵
Key insight: A value of 0 creates a potential dead-end

Asked in

a Amazon 82 G Google 67 ⊞ Microsoft 54 f Meta 43

The optimal solution uses a greedy approach with O(n) time and O(1) space. Instead of trying all possible paths, we track the furthest reachable position as we iterate. If we ever encounter a position beyond our reach, return false. Otherwise, keep extending our reach until we can reach the last index. The key insight is that we don't need the actual path - just whether the destination is reachable.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Approach (Optimal)	O(n)	O(1)	Track the furthest reachable position while iterating

Greedy Approach (Optimal) — Algorithm Steps

Initialize furthest reachable position as 0
Iterate through each position in the array
If current position > furthest reachable, return false
Update furthest reachable as max(furthest, current + nums[current])
If furthest reaches or exceeds last index, return true

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize furthest = 0

Start with the ability to reach position 0

Check reachability

Ensure current position ≤ furthest reachable

Update furthest

Extend furthest reachable based on current jump capacity

Early termination

Return true as soon as we can reach the last index

Code -

solution.c — C

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

bool canJump(int* nums, int numsSize) {
    int furthest = 0;
    
    for (int i = 0; i < numsSize; i++) {
        // If current position is beyond what we can reach
        if (i > furthest) {
            return false;
        }
        
        // Update furthest reachable position
        int newFurthest = i + nums[i];
        if (newFurthest > furthest) {
            furthest = newFurthest;
        }
        
        // Early termination if we can reach the end
        if (furthest >= numsSize - 1) {
            return true;
        }
    }
    
    return furthest >= numsSize - 1;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    int nums[1000], size = 0;
    char* token = strtok(line + 1, ",]");
    while (token) {
        nums[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    printf("%s\n", canJump(nums, size) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, checking each position once

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track furthest reachable position

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁴
0 ≤ nums[i] ≤ 10⁵
Key insight: A value of 0 creates a potential dead-end

89.3K Views

High Frequency

~15 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Greedy Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler