# Solving Leetcode Interviews in Seconds with AI: Subarray Sum Equals K


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "560" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> Given an array of integers nums and an integer k, return the total number of subarrays whose sum equals to k. A subarray is a contiguous non-empty sequence of elements within an array.   Example 1: Input: nums = [1,1,1], k = 2 Output: 2 Example 2: Input: nums = [1,2,3], k = 3 Output: 2    Constraints:  1 <= nums.length <= 2 * 104 -1000 <= nums[i] <= 1000 -107 <= k <= 107  

	# Explanation
	Here's a solution that addresses the problem efficiently:

*   **Prefix Sum:** Calculate the prefix sum of the array. This allows us to find the sum of any subarray in O(1) time by subtracting the prefix sums.
*   **Hash Map:** Store the frequency of each prefix sum encountered so far in a hash map. This allows us to efficiently check if there exists a previous subarray whose sum, when added to the current element, equals k.
*   **Count Subarrays:** Iterate through the array, updating the prefix sum and the hash map. If `prefix_sum - k` exists in the hash map, it means there's a subarray ending at the current index with a sum of k.

*   **Runtime Complexity:** O(n), **Storage Complexity:** O(n)

	
	# Code
	```python
	def subarray_sum(nums: list[int], k: int) -> int:
    """
    Given an array of integers nums and an integer k, return the total number of subarrays whose sum equals to k.
    A subarray is a contiguous non-empty sequence of elements within an array.

    Example 1:
    Input: nums = [1,1,1], k = 2
    Output: 2

    Example 2:
    Input: nums = [1,2,3], k = 3
    Output: 2

    Constraints:
    1 <= nums.length <= 2 * 104
    -1000 <= nums[i] <= 1000
    -107 <= k <= 107
    """

    prefix_sums = {0: 1}  # Initialize with 0:1 to handle cases where a subarray starting from index 0 sums to k
    current_sum = 0
    count = 0

    for num in nums:
        current_sum += num
        if current_sum - k in prefix_sums:
            count += prefix_sums[current_sum - k]
        if current_sum in prefix_sums:
            prefix_sums[current_sum] += 1
        else:
            prefix_sums[current_sum] = 1

    return count
	```