Subarray Sums Divisible by K

Subarray Sums Divisible by K - Problem

Given an integer array nums and an integer k, return the number of non-empty subarrays that have a sum divisible by k.

A subarray is a contiguous part of an array.

Example: If nums = [4,5,0,-2,-3,1] and k = 5, the subarrays with sums divisible by 5 are: [5] (sum=5), [5,0] (sum=5), [5,0,-2,-3] (sum=0), [0] (sum=0), [-2,-3] (sum=-5), and [4,5,0,-2,-3,1] (sum=5). Answer is 7.

Input & Output

Example 1 — Basic Case

$ Input: nums = [4,5,0,-2,-3,1], k = 5

› Output: 7

💡 Note: The subarrays with sums divisible by 5 are: [5] (sum=5), [5,0] (sum=5), [5,0,-2,-3] (sum=0), [0] (sum=0), [-2,-3] (sum=-5), [4,5,0,-2,-3,1] (sum=5), and one more subarray for a total of 7.

Example 2 — Small Array

$ Input: nums = [5], k = 9

› Output: 0

💡 Note: The only subarray is [5] with sum 5, which is not divisible by 9.

Example 3 — Multiple Divisible

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

› Output: 2

💡 Note: Subarrays with sums divisible by 6: [2,4] (sum=6). The answer is 1.

Constraints

1 ≤ nums.length ≤ 3 × 10⁴
-10⁴ ≤ nums[i] ≤ 10⁴
2 ≤ k ≤ 10⁴

Visualization

Tap to expand

Asked in

f Facebook 25 G Google 20 a Amazon 15

The key insight is using prefix sums and remainders: if two prefix sums have the same remainder when divided by k, the subarray between them has sum divisible by k. Best approach uses hash map to track remainder frequencies in O(n) time and O(k) space.

Common Approaches

✓ Brute Force

⏱️ Time: O(n³) Space: O(1)

Generate every possible subarray by trying all start and end positions. For each subarray, calculate its sum and check if it's divisible by k.

Prefix Sum with Hash Map

⏱️ Time: O(n) Space: O(k)

Calculate prefix sums and track remainder frequencies. Two prefix sums with the same remainder when divided by k indicate a subarray between them has sum divisible by k.

Brute Force — Algorithm Steps

Iterate through all possible start positions
For each start, iterate through all possible end positions
Calculate sum of current subarray and check if divisible by k

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subarrays

Try all start and end positions

Calculate Sums

Sum each subarray and check divisibility

Count Valid

Count subarrays with sum divisible by k

Code -

solution.c — C

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

static int nums[30000];

int solution(int* nums, int numsSize, int k) {
    int count = 0;
    
    for (int i = 0; i < numsSize; i++) {
        for (int j = i; j < numsSize; j++) {
            int subarraySum = 0;
            for (int l = i; l <= j; l++) {
                subarraySum += nums[l];
            }
            if (subarraySum % k == 0) {
                count++;
            }
        }
    }
    
    return count;
}

int main() {
    char line[100000];
    fgets(line, sizeof(line), stdin);
    
    int numsSize = 0;
    
    // Handle empty array case
    if (strstr(line, "[]")) {
        int k;
        scanf("%d", &k);
        printf("0\n");
        return 0;
    }
    
    // Parse array manually
    char* p = line;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        int sign = 1;
        if (*p == '-') {
            sign = -1;
            p++;
        }
        
        int num = 0;
        while (*p >= '0' && *p <= '9') {
            num = num * 10 + (*p - '0');
            p++;
        }
        nums[numsSize++] = sign * num;
    }
    
    int k;
    scanf("%d", &k);
    
    int result = solution(nums, numsSize, k);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Nested loops for start/end positions (O(n²)) and sum calculation (O(n)) for each subarray

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track positions and sum

✓ Linear Space

85.6K Views

Medium Frequency

~25 min Avg. Time

2.4K 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

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler