Jump Game Problem in DSA Javascript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Jump Game Reachability Check

What is the output of the following JavaScript code that checks if you can jump to the last index of the array?

DSA Javascript

function canJump(nums) {
  let maxReach = 0;
  for (let i = 0; i < nums.length; i++) {
    if (i > maxReach) return false;
    maxReach = Math.max(maxReach, i + nums[i]);
  }
  return true;
}

console.log(canJump([2,3,1,1,4]));

A undefined

B false

C TypeError

D true

💡 Hint

Think about whether the jumps allow reaching the last index.

The function checks if you can reach the last index by updating the maximum reachable index. Since the input allows reaching the end, it returns true.

❓ Predict Output

intermediate

Output when jump is blocked

What will the output be when the jump is blocked in the array?

DSA Javascript

function canJump(nums) {
  let maxReach = 0;
  for (let i = 0; i < nums.length; i++) {
    if (i > maxReach) return false;
    maxReach = Math.max(maxReach, i + nums[i]);
  }
  return true;
}

console.log(canJump([3,2,1,0,4]));

A true

B false

C ReferenceError

D null

💡 Hint

Check if the zero blocks the jump to the last index.

The zero at index 3 blocks any further jump, so the last index cannot be reached, returning false.

🧠 Conceptual

advanced

Understanding the Greedy Approach in Jump Game

Why does the greedy approach work for the Jump Game problem?

A Because it always chooses the jump that covers the farthest distance, ensuring the last index is reachable if possible.

B Because it tries all possible jump combinations recursively.

C Because it uses dynamic programming to store intermediate results.

D Because it sorts the array to find the best jumps.

💡 Hint

Think about how the algorithm updates the maximum reachable index.

The greedy method updates the maximum reachable index at each step, ensuring if the last index is reachable, it will find it without exploring all paths.

❓ Predict Output

advanced

Output of Minimum Jumps Calculation

What is the output of the following code that calculates the minimum number of jumps to reach the last index?

DSA Javascript

function jump(nums) {
  let jumps = 0, currentEnd = 0, farthest = 0;
  for (let i = 0; i < nums.length - 1; i++) {
    farthest = Math.max(farthest, i + nums[i]);
    if (i === currentEnd) {
      jumps++;
      currentEnd = farthest;
    }
  }
  return jumps;
}

console.log(jump([2,3,1,1,4]));

A 4

B 3

C 2

D 1

💡 Hint

Count how many jumps are needed to cover the array.

The minimum jumps to reach the last index in the array is 2: jump from index 0 to 1, then from 1 to 4.

🔧 Debug

expert

Identify the error in jump calculation code

What error will the following code produce when trying to calculate minimum jumps?

DSA Javascript

function jump(nums) {
  let jumps = 0, currentEnd = 0, farthest = 0;
  for (let i = 0; i <= nums.length - 1; i++) {
    farthest = Math.max(farthest, i + nums[i]);
    if (i === currentEnd) {
      jumps++;
      currentEnd = farthest;
    }
  }
  return jumps;
}

console.log(jump([2,3,1,1,4]));

A Infinite loop or incorrect jump count

B SyntaxError

C TypeError

D Returns 0

💡 Hint

Check the loop boundary condition and how jumps are counted.

The loop runs until i <= nums.length - 1, causing the last jump to be counted unnecessarily, leading to incorrect jump count or infinite loop in some cases.

Practice

1. What does the Jump Game problem ask you to determine given an array of non-negative integers?

easy

A. If you can reach the last index starting from the first index

B. The maximum jump length from any position

C. The minimum number of jumps to reach the last index

D. The sum of all jump lengths in the array

Solution

1. Step 1: Understand the problem statement

   The Jump Game problem asks if it is possible to move from the first index to the last index by jumping according to the values in the array.

2. Step 2: Identify the goal

   The goal is to check if the last index is reachable, not the number of jumps or maximum jump length.

3. Final Answer:

   If you can reach the last index starting from the first index -> Option A

4. Quick Check:

   Jump Game = Reach last index [OK]

Hint: Focus on reachability, not jump counts or sums [OK]

Common Mistakes:

• Confusing reachability with minimum jumps
• Thinking about maximum jump length only
• Assuming sum of jumps matters

2. Which of the following is the correct syntax to check if you can jump from index i to index j in JavaScript, given an array nums?

easy

A. if (nums[i] >= j - i)

B. if (nums[j] <= i + nums[i])

C. if (j < nums[i])

D. if (j <= i + nums[i])

Solution

1. Step 1: Understand jump condition

   You can jump from index i to j if j is within the jump length from i, i.e., j ≤ i + nums[i].

2. Step 2: Match condition with options

   if (j <= i + nums[i]) correctly checks if j ≤ i + nums[i]. Other options compare wrong values or use incorrect operators.

3. Final Answer:

   if (j <= i + nums[i]) -> Option D

4. Quick Check:

   Jump condition = j ≤ i + nums[i] [OK]

Hint: Check if target index ≤ current index + jump length [OK]

Common Mistakes:

• Comparing nums[j] instead of j
• Using < instead of ≤
• Mixing indices and values incorrectly

3. What will be the output of the following JavaScript code?

function canJump(nums) {
  let maxReach = 0;
  for (let i = 0; i < nums.length; i++) {
    if (i > maxReach) return false;
    maxReach = Math.max(maxReach, i + nums[i]);
  }
  return true;
}

console.log(canJump([2,3,1,1,4]));
console.log(canJump([3,2,1,0,4]));

medium

A. true false

B. true true

C. false true

D. false false

Solution

1. Step 1: Trace first input [2,3,1,1,4]

   maxReach updates as: i=0 maxReach=2, i=1 maxReach=4, i=2 maxReach=4, i=3 maxReach=4, i=4 maxReach=8. No i > maxReach, so returns true.

2. Step 2: Trace second input [3,2,1,0,4]

   maxReach updates: i=0 maxReach=3, i=1 maxReach=3, i=2 maxReach=3, i=3 maxReach=3, i=4 i=4 > maxReach=3 triggers return false.

3. Final Answer:

   true false -> Option A

4. Quick Check:

   First array reachable, second not [OK]

Hint: Track max reachable index; fail if current index exceeds it [OK]

Common Mistakes:

• Not updating maxReach correctly
• Returning true too early
• Ignoring the condition i > maxReach

4. Identify the bug in the following code that attempts to solve the Jump Game problem:

function canJump(nums) {
  let maxReach = 0;
  for (let i = 0; i <= nums.length; i++) {
    if (i > maxReach) return false;
    maxReach = Math.max(maxReach, i + nums[i]);
  }
  return true;
}

medium

A. maxReach should be initialized to 1, not 0

B. The loop condition should be i < nums.length, not i <= nums.length

C. The return true statement should be inside the loop

D. The comparison should be i >= maxReach instead of i > maxReach

Solution

1. Step 1: Analyze loop boundary

   The loop runs from i = 0 to i <= nums.length, which means it accesses nums[nums.length], causing undefined access.

2. Step 2: Correct loop condition

   The loop should run while i < nums.length to avoid out-of-bounds errors.

3. Final Answer:

   The loop condition should be i < nums.length, not i <= nums.length -> Option B

4. Quick Check:

   Loop boundary off by one error [OK]

Hint: Check array indices carefully to avoid out-of-bounds [OK]

Common Mistakes:

• Using <= instead of < in loops
• Misinitializing maxReach
• Placing return true inside loop

5. Given the array nums = [1,2,0,1,0,2,0], which of the following statements is true about reaching the last index using the Jump Game logic?

hard

A. You can reach the last index only if you jump exactly 2 steps each time

B. You can reach the last index because jumps can skip zeros if reachable

C. You cannot reach the last index because zeros block all paths

D. You can reach the last index only if you jump backward at some point

Solution

1. Step 1: Trace maxReach for [1,2,0,1,0,2,0]

   i=0, maxReach=1; i=1, maxReach=3; i=2, maxReach=3; i=3, maxReach=4; i=4, maxReach=4; i=5 >4, cannot reach index 6.

2. Step 2: Analyze blocking

   Zeros at indices 2,4 limit jumps from reachable positions (max=4), blocking paths to end.

3. Final Answer:

   You cannot reach the last index because zeros block all paths -> Option C

4. Quick Check:

   Max reach=4 < length-1=6 [OK]

Hint: Trace maxReach step-by-step; zeros block if they stall reach before end [OK]

Common Mistakes:

• Thinking zeros can always be skipped sufficiently
• Assuming jumps must be fixed length
• Believing backward jumps are allowed