Two Sum Problem Classic Hash Solution in DSA Go - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the main idea behind the Two Sum problem using a hash map?

Use a hash map to store numbers and their indices as you go through the list. For each number, check if the complement (target - current number) exists in the map. If yes, return the pair of indices.

beginner

Why is a hash map efficient for solving the Two Sum problem?

Because it allows checking if a number exists in constant time (O(1)), making the overall solution run in linear time (O(n)) instead of quadratic time (O(n²)).

beginner

In the Two Sum hash solution, what does the complement represent?

The complement is the number needed to add to the current number to reach the target sum. It is calculated as target - current number.

beginner

What happens if no two numbers add up to the target in the Two Sum hash solution?

The function returns an empty slice or nil, indicating no valid pair was found.

intermediate

Show the Go code snippet to check if the complement exists in the hash map during Two Sum solution.

if idx, ok := hashMap[complement]; ok { return []int{idx, i} }

What is the time complexity of the Two Sum problem using a hash map?

A O(1)

B O(n²)

C O(log n)

D O(n)

Using a hash map allows checking complements in constant time, so the overall time is linear, O(n).

In the Two Sum hash solution, what data structure stores numbers and their indices?

A Hash map

B Array

C Stack

D Queue

A hash map stores numbers as keys and their indices as values for quick lookup.

What does the complement equal in the Two Sum problem?

A target - current number

B target + current number

C current number - target

D current number * target

Complement is target minus the current number to find the needed pair.

What should the Two Sum function return if no pair is found?

A The input array

B Indices of the first two numbers

C Empty slice or nil

D The target value

Returning an empty slice or nil indicates no valid pair was found.

Which Go keyword is used to check if a key exists in a map?

A exists

B ok

C found

D found, ok

The idiomatic Go syntax uses 'value, ok := map[key]' where ok is true if key exists.

Explain step-by-step how the Two Sum problem is solved using a hash map.

Think about how you remember numbers and check for their pair quickly.

Write the Go code for the Two Sum problem using a hash map and explain how it works.

Focus on map usage and complement logic.

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