Jump Game

Jump Game - Problem

You are given an integer array nums. You are initially positioned at the array's first index, and each element in the array represents your maximum jump length at that position.

Return true if you can reach the last index, or false otherwise.

Input & Output

Example 1 — Basic 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. Or jump 2 steps from index 0 to 2, then 1 step to index 3, then 1 step to the last index.

Example 2 — Impossible Case

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

› Output: false

💡 Note: You will always arrive at index 3. Its maximum jump length is 0, so you cannot proceed further to reach the last index.

Example 3 — Single Element

$ Input: nums = [0]

› Output: true

💡 Note: Already at the last index, no jumping needed.

Constraints

1 ≤ nums.length ≤ 10⁴
0 ≤ nums[i] ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 f Meta 28

The greedy approach is optimal: track the maximum reachable position while iterating. If current position exceeds max reachable, return false. Time: O(n), Space: O(1).

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Bottom-Up Dynamic Programming

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

Work backwards from the last index, marking each position as 'good' or 'bad' based on whether it can reach the end.

Greedy Algorithm

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

Iterate through the array and keep track of the maximum index reachable. If current index is beyond the maximum reachable, return false.

Recursive Backtracking

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

From each position, recursively try every possible jump size from 1 to nums[i]. If any path reaches the end, return true.

Top-Down Dynamic Programming

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

Same recursive approach but store results for each position to avoid recalculating the same subproblems multiple times.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int parseArray(char* line, int** nums, int* numsSize) {
    *numsSize = 0;
    *nums = NULL;
    
    if (!line || strlen(line) < 3) return 0;
    
    // Count numbers first
    int count = 0;
    int inNumber = 0;
    for (int i = 0; i < strlen(line); i++) {
        if (isdigit(line[i])) {
            if (!inNumber) {
                count++;
                inNumber = 1;
            }
        } else {
            inNumber = 0;
        }
    }
    
    *numsSize = count;
    *nums = (int*)malloc(count * sizeof(int));
    
    // Parse numbers
    int idx = 0;
    int i = 0;
    while (i < strlen(line) && idx < count) {
        if (isdigit(line[i])) {
            int num = 0;
            while (i < strlen(line) && isdigit(line[i])) {
                num = num * 10 + (line[i] - '0');
                i++;
            }
            (*nums)[idx++] = num;
        } else {
            i++;
        }
    }
    
    return 1;
}

int canJump(int* nums, int numsSize) {
    if (numsSize <= 1) return 1;
    
    int maxReach = 0;
    
    for (int i = 0; i < numsSize - 1; i++) {
        // If current position is beyond what we can reach, return false
        if (i > maxReach) {
            return 0;
        }
        
        // Update the farthest position we can reach
        int newReach = i + nums[i];
        if (newReach > maxReach) {
            maxReach = newReach;
        }
        
        // If we can already reach the last index, return true
        if (maxReach >= numsSize - 1) {
            return 1;
        }
    }
    
    return maxReach >= numsSize - 1;
}

int main() {
    char line[10000];
    if (!fgets(line, sizeof(line), stdin)) return 1;
    
    // Remove newline
    int len = strlen(line);
    if (len > 0 && line[len-1] == '\n') line[len-1] = '\0';
    
    int* nums;
    int numsSize;
    
    if (!parseArray(line, &nums, &numsSize)) return 1;
    
    int result = canJump(nums, numsSize);
    
    printf("%s\n", result ? "true" : "false");
    
    free(nums);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

78.0K Views

High Frequency

~15 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