Jump Game Problem in DSA Go - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Jump Game Reachability Check

What is the output of this Go code that checks if you can jump to the last index?

DSA Go

package main
import "fmt"
func canJump(nums []int) bool {
    maxReach := 0
    for i := 0; i < len(nums); i++ {
        if i > maxReach {
            return false
        }
        if i+nums[i] > maxReach {
            maxReach = i + nums[i]
        }
    }
    return true
}
func main() {
    nums := []int{2,3,1,1,4}
    fmt.Println(canJump(nums))
}

A Runtime panic

B false

C Compilation error

D true

💡 Hint

Think about whether the jumps allow reaching the last index.

The code tracks the furthest reachable index. Since the input allows reaching the end, it returns true.

❓ Predict Output

intermediate

Output for Unreachable Last Index

What does this Go code print when the last index is not reachable?

DSA Go

package main
import "fmt"
func canJump(nums []int) bool {
    maxReach := 0
    for i := 0; i < len(nums); i++ {
        if i > maxReach {
            return false
        }
        if i+nums[i] > maxReach {
            maxReach = i + nums[i]
        }
    }
    return true
}
func main() {
    nums := []int{3,2,1,0,4}
    fmt.Println(canJump(nums))
}

A true

B Compilation error

C false

D Runtime panic

💡 Hint

Check if the zero at index 3 blocks progress.

The zero at index 3 prevents reaching index 4, so the function returns false.

🔧 Debug

advanced

Identify the Bug in Jump Game Code

What error does this Go code produce when run?

DSA Go

package main
import "fmt"
func canJump(nums []int) bool {
    maxReach := 0
    for i := 0; i < len(nums); i++ {
        if i > maxReach {
            return false
        }
        if i+nums[i] > maxReach {
            maxReach = i + nums[i]
        }
    }
    return true
}
func main() {
    nums := []int{2,3,1,1,4}
    fmt.Println(canJump(nums))
}

A Returns true correctly

B Index out of range runtime panic

C Returns false incorrectly

D Compilation error due to missing import

💡 Hint

Check the loop condition and array indexing carefully.

The loop goes to i <= len(nums), which causes an index out of range panic when accessing nums[i].

🧠 Conceptual

advanced

Minimum Jumps to Reach Last Index

Given an array where each element represents max jump length, which approach finds the minimum number of jumps to reach the last index?

A Greedy approach updating current jump end and next max reach

B Depth-first search exploring all paths

C Sorting the array and picking largest jumps first

D Using a stack to store all jump indices

💡 Hint

Think about tracking the farthest reachable index within current jumps.

The greedy approach efficiently tracks the current jump boundary and updates the next max reach to count minimum jumps.

🚀 Application

expert

Output of Minimum Jumps Calculation

What is the output of this Go code that calculates minimum jumps to reach the last index?

DSA Go

package main
import "fmt"
func jump(nums []int) int {
    jumps, curEnd, curFarthest := 0, 0, 0
    for i := 0; i < len(nums)-1; i++ {
        if i+nums[i] > curFarthest {
            curFarthest = i + nums[i]
        }
        if i == curEnd {
            jumps++
            curEnd = curFarthest
        }
    }
    return jumps
}
func main() {
    nums := []int{2,3,1,1,4}
    fmt.Println(jump(nums))
}

A 2

B 3

C 4

D 1

💡 Hint

Count how many times you need to jump to cover the array.

The minimum jumps to reach the last index is 2 for this input.

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 by jumping within allowed steps

B. The maximum jump length you can make 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 you can move from the first index to the last index by jumping forward within the allowed steps at each position.

2. Step 2: Identify the key question

   The key question is whether the last index is reachable, not how many jumps or maximum jump length.

3. Final Answer:

   If you can reach the last index starting from the first index by jumping within allowed steps -> Option A

4. Quick Check:

   Jump Game = Reach last index? [OK]

Hint: Focus on reachability, not jump count or max jump length [OK]

Common Mistakes:

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

2. Which of the following Go code snippets correctly declares an integer slice representing jump lengths for the Jump Game?

easy

A. jumps := [2, 3, 1, 1, 4]

B. jumps := (2, 3, 1, 1, 4)

C. jumps := int{2, 3, 1, 1, 4}

D. jumps := []int{2, 3, 1, 1, 4}

Solution

1. Step 1: Recall Go slice declaration syntax

   In Go, slices are declared with []type and curly braces for values, e.g., []int{...}.

2. Step 2: Check each option

   Only jumps := []int{2, 3, 1, 1, 4} uses correct slice syntax. The others use array syntax, invalid int{}, or parentheses.

3. Final Answer:

   jumps := []int{2, 3, 1, 1, 4} -> Option D

4. Quick Check:

   Slice declaration = []int{values} [OK]

Hint: Use []int{...} to declare integer slices in Go [OK]

Common Mistakes:

• Using square brackets without type for slices
• Using parentheses instead of braces
• Confusing arrays and slices syntax

3. What is the output of the following Go code snippet for the Jump Game problem?

package main

import "fmt"

func canJump(nums []int) bool {
    maxReach := 0
    for i := 0; i < len(nums); i++ {
        if i > maxReach {
            return false
        }
        if i+nums[i] > maxReach {
            maxReach = i + nums[i]
        }
    }
    return true
}

func main() {
    nums := []int{2, 3, 1, 1, 4}
    fmt.Println(canJump(nums))
}

medium

A. true

B. false

C. Compilation error

D. Runtime panic

Solution

1. Step 1: Trace maxReach updates

   Start maxReach=0. At i=0, maxReach=max(0,0+2)=2. i=1 ≤ 2, maxReach=max(2,1+3)=4. i=2 ≤ 4, maxReach=max(4,2+1)=4. i=3 ≤ 4, maxReach=max(4,3+1)=4. i=4 ≤ 4, maxReach=max(4,4+4)=8.

2. Step 2: Check if any index is unreachable

   All i ≤ maxReach, so no false return. Loop ends, returns true.

3. Final Answer:

   true -> Option A

4. Quick Check:

   All indices reachable = true [OK]

Hint: Track max reachable index; if current index exceeds it, return false [OK]

Common Mistakes:

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

4. Identify the bug in this Go function for the Jump Game problem and select the fix:

func canJump(nums []int) bool {
    maxReach := 0
    for i := 0; i <= len(nums); i++ {
        if i > maxReach {
            return false
        }
        if i+nums[i] > maxReach {
            maxReach = i + nums[i]
        }
    }
    return true
}

medium

A. Remove the if condition checking i > maxReach

B. Initialize maxReach to 1 instead of 0

C. Change loop condition to i < len(nums)

D. Change return false to return true inside the loop

Solution

1. Step 1: Analyze loop boundary

   The loop runs with i <= len(nums), which causes index out of range error at i == len(nums).

2. Step 2: Fix loop condition

   Changing to i < len(nums) prevents out of range access and fixes the bug.

3. Final Answer:

   Change loop condition to i < len(nums) -> Option C

4. Quick Check:

   Loop index must be less than slice length [OK]

Hint: Use i < len(slice) to avoid index out of range errors [OK]

Common Mistakes:

• Using <= instead of < in loop condition
• Ignoring runtime panic from out of range
• Changing unrelated parts of code

5. Given the array nums := []int{3, 2, 1, 0, 4}, what is the result of applying the Jump Game algorithm to check if the last index is reachable?

hard

A. true

B. false

C. Runtime error due to zero jump

D. Depends on starting index

Solution

1. Step 1: Trace maxReach through the array

   Start maxReach=0. i=0: maxReach=max(0,0+3)=3. i=1 ≤ 3: maxReach=max(3,1+2)=3. i=2 ≤ 3: maxReach=max(3,2+1)=3. i=3 ≤ 3: maxReach=max(3,3+0)=3. i=4 > 3, so return false.

2. Step 2: Understand why last index is unreachable

   At index 3, jump length is 0, so maxReach does not increase. Index 4 is beyond maxReach, unreachable.

3. Final Answer:

   false -> Option B

4. Quick Check:

   Zero jump blocks progress = false [OK]

Hint: If maxReach stops before last index, return false [OK]

Common Mistakes:

• Assuming zero jump can be bypassed
• Ignoring unreachable last index
• Thinking runtime error occurs