Continuous Subarray Sum - Practice Coding Problems

Continuous Subarray Sum - Problem

Given an integer array nums and an integer k, determine if there exists a good subarray within the array.

A good subarray must satisfy two conditions:

Its length is at least 2 (contains at least two elements)
The sum of its elements is a multiple of k

Key Points:

A subarray is a contiguous sequence of elements from the array
An integer x is a multiple of k if x = n × k for some integer n
0 is always considered a multiple of any integer k

Return true if such a good subarray exists, otherwise return false.

Input & Output

example_1.py — Basic Case

$ Input: nums = [23,2,4,6,7], k = 6

› Output: true

💡 Note: The subarray [2,4,6] has sum 12, which is divisible by 6 (12 = 2 × 6). The length is 3 ≥ 2, so this is a valid good subarray.

example_2.py — No Valid Subarray

$ Input: nums = [23,2,4,6,6], k = 7

› Output: false

💡 Note: No contiguous subarray of length ≥ 2 has a sum that is divisible by 7. We need to check all possible subarrays systematically.

example_3.py — Edge Case with Zero

$ Input: nums = [5,0,0], k = 3

› Output: true

💡 Note: The subarray [0,0] has sum 0, and 0 is always a multiple of any integer k. The length is 2 ≥ 2, making this a valid good subarray.

Visualization

Tap to expand

rem=5sum=25
rem=1sum=29
rem=5sum=35
rem=5sum=42
rem=0Same remainder 5!Subarray [2,4,6] = 12 ÷ 6 = 0💡 Key Insight: When prefix_sum % k repeats, the subarray between has sum divisible by k!If sum[0..i] ≡ sum[0..j] (mod k), then sum[i+1..j] ≡ 0 (mod k)This is because: sum[i+1..j] = sum[0..j] - sum[0..i]Continuous Subarray Sum - Prefix Sum Remainder Magic

Understanding the Visualization

Track Running Totals

Keep a running sum and calculate remainder when divided by k

Remember Patterns

Store each remainder and when we first saw it

Find Repeats

When we see the same remainder again, we found our answer!

Check Distance

Ensure the subarray has length ≥ 2 elements

Key Takeaway

🎯 Key Insight: The modular arithmetic approach transforms a seemingly complex problem into an elegant O(n) solution by recognizing that repeated remainders indicate divisible subarrays between them.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array, hash map operations are O(1) average case

✓ Linear Growth

Space Complexity

O(min(n,k))

Hash map stores at most k different remainders (0 to k-1), but could be less than n elements

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁹
1 ≤ k ≤ 2³¹ - 1
Subarray must have length ≥ 2

Asked in

G Google 45 f Facebook 38 a Amazon 32 ⊞ Microsoft 28

The optimal solution uses prefix sum remainders and a hash map to solve this in O(n) time. The key insight is that if two prefix sums have the same remainder when divided by k, then the subarray between them has sum divisible by k. We track remainders and their indices, returning true when we find a repeated remainder with sufficient distance.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	Check every possible subarray of length ≥ 2 and calculate its sum
One-Pass Hash Table (Optimal)	O(n)	O(min(n,k))	Use prefix sum remainders and hash map to find subarrays in O(n) time

Brute Force (Nested Loops) — Algorithm Steps

Iterate through each starting position i from 0 to n-2
For each starting position, iterate through ending positions j from i+1 to n-1
Calculate the sum of elements from index i to j
Check if the sum is divisible by k (sum % k == 0)
Return true if found, false if no such subarray exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first element

Begin checking subarrays starting from index 0

Extend subarray

Add each subsequent element and check sum divisibility

Move to next start

Repeat process starting from index 1, then 2, etc.

Code -

solution.c — C

#include <stdio.h>
#include <stdbool.h>

bool checkSubarraySum(int* nums, int numsSize, int k) {
    for (int i = 0; i < numsSize - 1; i++) {
        int currentSum = nums[i];
        for (int j = i + 1; j < numsSize; j++) {
            currentSum += nums[j];
            if (currentSum % k == 0) {
                return true;
            }
        }
    }
    return false;
}

int main() {
    int nums[] = {23, 2, 4, 6, 7};
    int k = 6;
    printf("%s\n", checkSubarraySum(nums, 5, k) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Two nested loops to generate all subarrays, sum calculation can be optimized to O(1) per subarray

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra variables for iteration and sum calculation

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁹
1 ≤ k ≤ 2³¹ - 1
Subarray must have length ≥ 2

89.0K Views

High Frequency

~25 min Avg. Time

2.5K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler