How I Finally Understood HashMap Usage in Continuous Subarray Sum (After Failing with Sliding Window)

Problem Background

While solving the Continuous Subarray Sum problem on LeetCode, I initially felt confident because the word subarray immediately triggered my sliding window intuition. I had been practicing two pointers and sliding window patterns consistently, so my brain naturally tried to force that approach here.

Why Sliding Window Failed for Me

I tried hard to find a condition to either expand or shrink the window. But no matter how I looked at it, something felt off.

• The sum does not behave monotonically
• There is no clear rule to shrink the window
• Checking divisibility by k gives no directional hint

That’s when I realized this problem does not belong to the sliding window family. The confusion I was facing was actually a signal that I was applying the wrong pattern.

The YouTube Insight That Changed Everything

After watching a YouTube tutorial focused only on intuition, one key idea finally clicked:

If the same remainder appears again while taking prefix sum modulo k, the sum in between is divisible by k.

This was the missing mental bridge. I wasn’t supposed to track window size — I was supposed to track state repetition.

Why HashMap Suddenly Made Sense

Instead of thinking in terms of subarrays, I started thinking in terms of prefix states:

• Maintain a running prefix sum
• Store prefix_sum % k in a hashmap
• If the same remainder appears again after at least 2 indices, we’ve found the answer

This explains why a HashMap is required — we’re not searching, we’re remembering.

My Final Code

Here is the exact implementation I used (and the one I referenced in my GitHub repository):

class Solution:
    def checkSubarraySum(self, nums: List[int], k: int) -> bool:
        h_set = {0: -1}
        s = 0
        for index, i in enumerate(nums):
            s += i
            if s % k in h_set:
                if index - h_set[s % k] >= 2:
                    return True
            else:
                h_set[s % k] = index
        return False

GitHub Solution

You can view the full solution on GitHub here:
https://github.com/RohitSingh-04/Python-Solutions/blob/main/LC523.py

What I Learned from This Problem

• Not every subarray problem is sliding window
• If there is no shrinking condition, sliding window is a red flag
• Repeated prefix states often indicate HashMap usage
• YouTube intuition videos are useful when used correctly

Final Thoughts

Initially, HashMap usage felt unintuitive and forced. But after understanding the remainder logic, it now feels inevitable. This problem taught me that getting stuck is part of pattern recognition — and sometimes, the breakthrough comes from realizing why your first idea doesn’t work.

This was a solid reminder that learning DSA is not about memorizing solutions, but about reshaping how you think.