Subarray Sums Divisible by K - Practice Coding Problems

Subarray Sums Divisible by K - Problem

You're given an integer array nums and an integer k. Your task is to find the number of contiguous subarrays whose sum is divisible by k.

A subarray is a contiguous part of an array, meaning elements must be adjacent to each other. For example, in array [4, 5, 0, -2, -3, 1] with k = 5, subarrays like [5], [5, 0], and [0, -2, -3] have sums divisible by 5.

Goal: Count all such subarrays efficiently without generating them explicitly.

Input & Output

example_1.py — Basic Case

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

› Output: 7

💡 Note: The subarrays with sums divisible by 5 are: [5], [5,0], [5,0,-2,-3], [0], [0,-2,-3], [-2,-3], and [4,5,0,-2,-3,1] (whole array). Total count = 7.

example_2.py — Single Element

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

› Output: 0

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

example_3.py — All Elements Divisible

$ Input: nums = [3,6,9], k = 3

› Output: 6

💡 Note: All possible subarrays have sums divisible by 3: [3], [6], [9], [3,6], [6,9], [3,6,9]. Total count = 6.

Constraints

1 ≤ nums.length ≤ 3 × 10⁴
-10⁴ ≤ nums[i] ≤ 10⁴
2 ≤ k ≤ 10⁴
Note: Array can contain negative numbers

Visualization

Tap to expand

Understanding the Visualization

Initialize

Start with remainder 0 seen once (empty prefix)

Process Elements

For each element, update prefix sum and find remainder

Count & Update

Add current remainder frequency to result, then increment frequency

Key Takeaway

🎯 Key Insight: Modular arithmetic transforms the subarray sum problem into a frequency counting problem!

Asked in

a Amazon 45 G Google 38 f Meta 32 ⊞ Microsoft 28 Apple 22

The optimal solution uses prefix sums and a hash map to track remainder frequencies. Key insight: if two prefix sums have the same remainder mod k, the subarray between them is divisible by k. This achieves O(n) time and O(k) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Subarrays)	O(n²)	O(1)	Check every possible subarray and calculate its sum
Prefix Sum + Hash Map (Optimal)	O(n)	O(min(n, k))	Use prefix sums and remainder frequencies to count in one pass

Brute Force (Check All Subarrays) — Algorithm Steps

Use outer loop for starting index i
Use inner loop for ending index j (from i to n-1)
Calculate sum of subarray from i to j
Check if sum % k == 0, increment counter if true

Visualization

Tap to expand

Step-by-Step Walkthrough

Outer Loop

Start with first element as beginning of subarray

Inner Loop

Extend subarray one element at a time

Check Sum

Calculate running sum and check divisibility

Code -

solution.c — C

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

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

int main() {
    int nums[] = {4, 5, 0, -2, -3, 1};
    int k = 5;
    printf("%d\n", subarraysDivByK(nums, 6, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops generate O(n²) subarrays, each sum calculation takes O(1) with running sum

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track count and current sum

✓ Linear Space

38.2K Views

High Frequency

~18 min Avg. Time

1.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

Brute Force (Check All Subarrays) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler