Codestin Search App

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.

Constraints

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

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.

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
✓ 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)	O(n²)	O(1)	Check every possible subarray of length ≥ 2 and calculate its sum

One-Pass Hash Table (Optimal) — Algorithm Steps

Initialize hash map with {0: -1} to handle subarrays starting from index 0
Iterate through array, maintaining running prefix sum
Calculate remainder = prefix_sum % k
If remainder seen before and distance ≥ 2, return True
Otherwise, store remainder with current index in hash map
Return False if no valid subarray found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with remainder_map = {0: -1} and prefix_sum = 0

Track remainders

For each element, update prefix sum and calculate remainder

Find pattern

When remainder repeats with distance > 1, we found our answer

Code -

solution.c — C

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

typedef struct {
    int remainder;
    int index;
} RemainderEntry;

bool checkSubarraySum(int* nums, int numsSize, int k) {
    RemainderEntry* remainderMap = (RemainderEntry*)malloc(k * sizeof(RemainderEntry));
    for (int i = 0; i < k; i++) {
        remainderMap[i].remainder = -1;
    }
    remainderMap[0].remainder = 0;
    remainderMap[0].index = -1;
    
    int prefixSum = 0;
    for (int i = 0; i < numsSize; i++) {
        prefixSum += nums[i];
        int remainder = prefixSum % k;
        
        if (remainderMap[remainder].remainder != -1) {
            if (i - remainderMap[remainder].index > 1) {
                free(remainderMap);
                return true;
            }
        } else {
            remainderMap[remainder].remainder = remainder;
            remainderMap[remainder].index = i;
        }
    }
    
    free(remainderMap);
    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)

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

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

Constraints

Visualization

Related Problems

Common Approaches

One-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler