Why Subarray Sum Equals K Using Hash Map in DSA Go?

The Big Idea

What if you could find exact spending periods instantly without checking every possibility?

The Scenario

Imagine you have a long list of daily expenses, and you want to find if there is a continuous period where the total spending equals exactly $100. Doing this by checking every possible period manually would take forever.

The Problem

Manually adding sums for every possible sub-list means repeating many calculations, which is slow and tiring. It's easy to make mistakes and miss some periods, especially when the list is very long.

The Solution

Using a hash map, we keep track of sums we have seen so far. This helps us quickly find if a previous sum matches the current sum minus the target, so we know a subarray sums to the target without checking all sub-lists again.

Before vs After

✗ Before

for i := 0; i < len(nums); i++ {
  sum := 0
  for j := i; j < len(nums); j++ {
    sum += nums[j]
    if sum == k {
      return true
    }
  }
}

✓ After

sumCount := map[int]int{0:1}
sum := 0
for _, num := range nums {
  sum += num
  if sumCount[sum-k] > 0 {
    return true
  }
  sumCount[sum]++
}

What It Enables

This method lets you find continuous sums equal to a target in a list quickly and efficiently, even for very large lists.

Real Life Example

Finding a period in your bank statement where your spending exactly matches a budget goal, without checking every possible date range manually.

Key Takeaways

Manual checking of all subarrays is slow and error-prone.

Hash map stores sums seen so far to find matches quickly.

Efficiently finds subarrays summing to target in one pass.

Practice

1. What is the main purpose of using a hash map in the Subarray Sum Equals K problem?

easy

A. To store the original array elements as keys

B. To sort the array elements before processing

C. To store cumulative sums and their frequencies for quick lookup

D. To keep track of the maximum subarray length

Solution

1. Step 1: Understand the problem goal

   The problem requires finding subarrays whose sums equal a target value k.

2. Step 2: Role of hash map in solution

   A hash map stores cumulative sums seen so far and their counts, enabling quick checks if a previous sum exists that forms a subarray summing to k.

3. Final Answer:

   To store cumulative sums and their frequencies for quick lookup -> Option C

4. Quick Check:

   Hash map = cumulative sums storage [OK]

Hint: Hash map tracks sums to find subarrays fast [OK]

Common Mistakes:

• Thinking hash map stores array elements as keys
• Assuming sorting is needed
• Confusing hash map with array for sums

2. Which of the following Go code snippets correctly initializes a hash map to store integer keys and values for the subarray sum problem?

easy

A. m := make([]int, 0)

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

C. m := map[int]string{}

D. m := map[string]int{}

Solution

1. Step 1: Identify correct map type for keys and values

   We need a map with integer keys and integer values to store sums and counts.

2. Step 2: Check Go syntax for map initialization

   make(map[int]int) correctly creates a map with int keys and int values.

3. Final Answer:

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

4. Quick Check:

   map[int]int = correct map type [OK]

Hint: Use make(map[int]int) for int keys and values [OK]

Common Mistakes:

• Using slice instead of map
• Wrong key or value types in map
• Using map with string keys incorrectly

3. What is the output of the following Go code snippet?

nums := []int{1, 2, 3}
k := 3
count := 0
sum := 0
m := make(map[int]int)
m[0] = 1
for _, v := range nums {
    sum += v
    if val, ok := m[sum-k]; ok {
        count += val
    }
    m[sum]++
}
fmt.Println(count)

medium

A. 1

B. 0

C. 3

D. 2

Solution

1. Step 1: Trace cumulative sums and map updates

   Iteration 1: sum=1, m[1]=1, sum-k=-2 not in map, count=0 Iteration 2: sum=3, sum-k=0 in map with count 1, count=1, m[3]=1 Iteration 3: sum=6, sum-k=3 in map with count 1, count=2, m[6]=1

2. Step 2: Final count after loop

   Count is 2 because two subarrays sum to k=3: [1,2] and [3].

3. Final Answer:

   2 -> Option D

4. Quick Check:

   Subarrays summing to 3 = 2 [OK]

Hint: Count increments when (sum-k) found in map [OK]

Common Mistakes:

• Not initializing m[0] = 1
• Forgetting to increment map count
• Miscounting subarrays

4. Identify the bug in the following Go code snippet for counting subarrays summing to k:

nums := []int{1, 1, 1}
k := 2
count := 0
sum := 0
m := make(map[int]int)
for _, v := range nums {
    sum += v
    if val, ok := m[sum-k]; ok {
        count += val
    }
    m[sum]++
}
fmt.Println(count)

medium

A. Missing initialization m[0] = 1 before loop

B. Incorrect increment of count variable

C. Wrong loop variable used

D. Using map with wrong key type

Solution

1. Step 1: Check map initialization

   The map m is used to store cumulative sums, but m[0] is not initialized to 1 before the loop.

2. Step 2: Effect of missing m[0] = 1

   Without m[0] = 1, subarrays starting from index 0 that sum to k are not counted, causing incorrect count.

3. Final Answer:

   Missing initialization m[0] = 1 before loop -> Option A

4. Quick Check:

   Initialize m[0]=1 to count subarrays from start [OK]

Hint: Always set m[0] = 1 before loop [OK]

Common Mistakes:

• Not initializing m[0]
• Incrementing count incorrectly
• Using wrong map key type

5. Given the array nums = []int{3, 4, 7, 2, -3, 1, 4, 2} and k = 7, how many subarrays sum to k? Use the hash map approach to find the count.

hard

A. 4

B. 3

C. 6

D. 5

Solution

1. Step 1: Calculate cumulative sums and track counts

   Initialize m[0]=1, sum=0, count=0 Iterate nums: - sum=3, sum-k=-4 not in m, m[3]=1 - sum=7, sum-k=0 in m=1, count=1, m[7]=1 - sum=14, sum-k=7 in m=1, count=2, m[14]=1 - sum=16, sum-k=9 not in m, m[16]=1 - sum=13, sum-k=6 not in m, m[13]=1 - sum=14, sum-k=7 in m=1, count=3, m[14]=2 - sum=18, sum-k=11 not in m, m[18]=1 - sum=20, sum-k=13 in m=1, count=4, m[20]=1

2. Step 2: Verify subarrays

   The subarrays summing to 7 are: [3,4], [7], [7,2,-3,1], [1,4,2]. Total count = 4.

3. Final Answer:

   4 -> Option A

4. Quick Check:

   Count subarrays with sum k = 4 [OK]

Hint: Track cumulative sums and counts carefully [OK]

Common Mistakes:

• Missing m[0] initialization
• Miscounting overlapping subarrays
• Not updating map counts correctly