Two Sum Problem Classic Hash Solution in DSA Go - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Two Sum Classic Hash Solution with distinct pairs

What is the output of this Go code that finds indices of two numbers adding up to target 9?

DSA Go

package main
import "fmt"
func twoSum(nums []int, target int) []int {
    hash := make(map[int]int)
    for i, num := range nums {
        complement := target - num
        if j, ok := hash[complement]; ok {
            return []int{j, i}
        }
        hash[num] = i
    }
    return nil
}
func main() {
    nums := []int{2, 7, 11, 15}
    target := 9
    result := twoSum(nums, target)
    fmt.Println(result)
}

A [0 1]

B [1 0]

C []

D [2 3]

💡 Hint

Think about which two numbers add up to 9 and their indices in the slice.

The function uses a map to store numbers and their indices. It finds that 2 (index 0) and 7 (index 1) add up to 9, so it returns [0 1].

❓ Predict Output

intermediate

Output when no two numbers sum to target

What does the Go code print when no two numbers add up to the target 10?

DSA Go

package main
import "fmt"
func twoSum(nums []int, target int) []int {
    hash := make(map[int]int)
    for i, num := range nums {
        complement := target - num
        if j, ok := hash[complement]; ok {
            return []int{j, i}
        }
        hash[num] = i
    }
    return nil
}
func main() {
    nums := []int{1, 2, 3, 4}
    target := 10
    result := twoSum(nums, target)
    fmt.Println(result)
}

A []

B [0 3]

C [1 2]

D nil

💡 Hint

Check if any two numbers in the slice add up to 10.

No pair sums to 10, so the function returns nil, which prints as [].

🔧 Debug

advanced

Identify the runtime error in Two Sum implementation

What error does this Go code produce when run?

DSA Go

package main
import "fmt"
func twoSum(nums []int, target int) []int {
    hash := make(map[int]int)
    for i, num := range nums {
        complement := target - num
        if j, ok := hash[complement]; ok {
            return []int{j, i}
        }
        // Missing assignment to hash[num]
    }
    return nil
}
func main() {
    nums := []int{3, 2, 4}
    target := 6
    result := twoSum(nums, target)
    fmt.Println(result)
}

A []int{1, 2}

B nil

C []

D runtime error: index out of range

💡 Hint

Check if the map is updated correctly inside the loop.

The map is never updated with nums[i], so no complement is found. The function returns nil, which prints as but fmt.Println prints empty slice as [].

❓ Predict Output

advanced

Output of Two Sum with duplicate numbers

What is the output of this Go code when the input slice contains duplicates?

DSA Go

package main
import "fmt"
func twoSum(nums []int, target int) []int {
    hash := make(map[int]int)
    for i, num := range nums {
        complement := target - num
        if j, ok := hash[complement]; ok {
            return []int{j, i}
        }
        hash[num] = i
    }
    return nil
}
func main() {
    nums := []int{3, 3, 4, 5}
    target := 6
    result := twoSum(nums, target)
    fmt.Println(result)
}

A [2 3]

B [1 2]

C [0 1]

D []

💡 Hint

Look for two numbers that add up to 6 and their earliest indices.

The first 3 at index 0 and the second 3 at index 1 add up to 6, so output is [0 1].

🧠 Conceptual

expert

Why does the Two Sum hash solution return indices in order of first found pair?

Why does the classic Two Sum hash map solution return the indices of the first pair found that sums to the target?

A Because the map stores all indices and returns the pair with the smallest sum of indices

B Because the function always returns the last pair found in the array

C Because the map sorts the numbers and returns the pair with the smallest numbers

D Because the loop checks complements in the map before adding the current number, so the first valid pair is returned immediately

💡 Hint

Think about the order of operations inside the loop.

The function checks if the complement exists in the map before adding the current number, so the first pair found is returned immediately.

Practice

1. What is the main idea behind the Two Sum Problem Classic Hash Solution?

easy

A. Use a hash map to store numbers and their indices for quick lookup

B. Sort the array and use two pointers to find the sum

C. Use nested loops to check every pair of numbers

D. Use recursion to find pairs that add up to the target

Solution

1. Step 1: Understand the problem goal

   The goal is to find two numbers in the array that add up to a target value.

2. Step 2: Use a hash map for efficient lookup

   By storing each number and its index in a hash map, we can check if the complement (target - current number) exists quickly.

3. Final Answer:

   Use a hash map to store numbers and their indices for quick lookup -> Option A

4. Quick Check:

   Hash map lookup = fast pair finding [OK]

Hint: Use a hash map to find complements quickly [OK]

Common Mistakes:

• Trying to use nested loops which is slower
• Sorting the array which is unnecessary here
• Not storing indices with numbers

2. Which of the following Go code snippets correctly initializes a hash map to store integers as keys and values?

easy

A. var m map[int]int

B. m := map[int]int

C. m := make(map[int]int)

D. m := map[int]int(make())

Solution

1. Step 1: Recall Go map initialization syntax

   Maps in Go are initialized using the built-in make function like make(map[keyType]valueType).

2. Step 2: Identify correct syntax

   m := make(map[int]int) uses make(map[int]int) which is the correct way to create an empty map with int keys and int values.

3. Final Answer:

   m := make(map[int]int) -> Option C

4. Quick Check:

   make(map[int]int) = correct map init [OK]

Hint: Use make(map[key]value) to create maps in Go [OK]

Common Mistakes:

• Using var without make causes nil map
• Incorrect syntax like map[int]int(make())
• Using empty braces without make in some contexts

3. What will be the output of the following Go code snippet?

func twoSum(nums []int, target int) []int {
    m := make(map[int]int)
    for i, num := range nums {
        if j, ok := m[target-num]; ok {
            return []int{j, i}
        }
        m[num] = i
    }
    return nil
}

fmt.Println(twoSum([]int{2, 7, 11, 15}, 9))

medium

A. [1 0]

B. [0 1]

C. [2 3]

D. nil

Solution

1. Step 1: Trace the loop and map updates

   At i=0, num=2, map is empty, so store m[2]=0.
   At i=1, num=7, check if m[9-7=2] exists, yes at index 0.
   Return [0,1].

2. Step 2: Confirm returned indices

   The function returns indices of numbers 2 and 7 which sum to 9, so output is [0 1].

3. Final Answer:

   [0 1] -> Option B

4. Quick Check:

   Indices of 2 and 7 = [0 1] [OK]

Hint: Check map for complement before inserting current number [OK]

Common Mistakes:

• Returning indices in wrong order
• Not checking map before insertion
• Returning nil when pair exists

4. Identify the error in the following Go code for the Two Sum problem:

func twoSum(nums []int, target int) []int {
    m := make(map[int]int)
    for i, num := range nums {
        if j, ok := m[num-target]; ok {
            return []int{j, i}
        }
        m[num] = i
    }
    return nil
}

medium

A. The complement calculation should be target - num, not num - target

B. The map should store num + target as key

C. The map initialization is incorrect

D. The return statement should return nil earlier

Solution

1. Step 1: Analyze complement calculation

   The complement to find is target - current number, not num - target, because we want a number that adds with num to target.

2. Step 2: Identify the fix

   Change m[num-target] to m[target-num] to correctly check for the complement in the map.

3. Final Answer:

   The complement calculation should be target - num, not num - target -> Option A

4. Quick Check:

   Complement = target - num [OK]

Hint: Complement = target minus current number [OK]

Common Mistakes:

• Swapping target and num in complement
• Incorrect map initialization
• Returning nil too early

5. Given the input array nums = [3, 3, 4, 2] and target 6, what will the Two Sum Classic Hash Solution return?
Consider the code below:

func twoSum(nums []int, target int) []int {
    m := make(map[int]int)
    for i, num := range nums {
        if j, ok := m[target-num]; ok {
            return []int{j, i}
        }
        m[num] = i
    }
    return nil
}

medium

A. nil

B. [1 2]

C. [2 3]

D. [0 1]

Solution

1. Step 1: Trace the loop with given input

   i=0, num=3, map empty, store m[3]=0.
   i=1, num=3, check m[6-3=3], found at index 0, return [0,1].

2. Step 2: Confirm returned indices

   Indices 0 and 1 correspond to values 3 and 3 which sum to 6, so output is [0 1].

3. Final Answer:

   [0 1] -> Option D

4. Quick Check:

   3 + 3 = 6 at indices [0 1] [OK]

Hint: Check map for complement before inserting current number [OK]

Common Mistakes:

• Assuming different pairs without checking map
• Returning nil when pair exists
• Confusing indices order