Count of Interesting Subarrays - Practice Coding Problems

Count of Interesting Subarrays - Problem

You are given a 0-indexed integer array nums, an integer modulo, and an integer k.

Your task is to find the count of subarrays that are "interesting".

A subarray nums[l..r] is interesting if:

Let cnt be the number of indices i in the range [l, r] such that nums[i] % modulo == k
Then, cnt % modulo == k

In other words, we need subarrays where the count of elements satisfying the modulo condition also satisfies the same modulo condition!

Return the total number of such interesting subarrays.

Note: A subarray is a contiguous non-empty sequence of elements within an array.

Input & Output

example_1.py — Basic case

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

› Output: 3

💡 Note: Special elements are those where nums[i] % 2 == 1, so [3,4] are special. Subarrays with count % 2 == 1: [3] (1 special), [2,4] (1 special), [3,2,4] (2 special elements, but 2%2≠1), so actually [3], [4], [3,2,4] won't work. Let me recalculate: [3] has 1 special, 1%2=1 ✓, [2] has 0 special, 0%2≠1, [4] has 1 special, 1%2=1 ✓, [3,2] has 1 special, 1%2=1 ✓. Answer is 3.

example_2.py — All elements special

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

› Output: 6

💡 Note: Special elements are [3,9,6] (indices 0,2,3). We want subarrays where count of special elements % 3 == 0. Subarrays with 0 special: [1]. Subarrays with 3 special: [3,1,9,6]. Total valid subarrays: 6.

example_3.py — No special elements

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

› Output: 0

💡 Note: No elements satisfy nums[i] % 3 == 1, so all subarrays have 0 special elements. Since 0 % 3 ≠ 1, no subarrays are interesting.

Visualization

Tap to expand

Understanding the Visualization

Setup Magic Ledger

Initialize with empty chest count {remainder_0: 1}

Process Each Gem

Check if gem is special, update running count

Calculate Remainders

Find what previous remainder would give us target count

Count Matches

Look up matching chests in our ledger

Update Ledger

Record current chest configuration

Key Takeaway

🎯 Key Insight: By tracking prefix remainder frequencies, we can count valid subarrays in O(n) time instead of checking all O(n²) possibilities!

Time & Space Complexity

Time Complexity

⏱️

O(n)

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

✓ Linear Growth

Space Complexity

O(min(n, modulo))

Hash map stores at most modulo different remainders

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
1 ≤ modulo ≤ 10⁹
0 ≤ k < modulo

Asked in

G Google 25 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The optimal solution uses prefix sums with hash map to solve this in O(n) time. The key insight is that if two prefix positions have remainders that differ by k (modulo m), then the subarray between them has exactly k special elements (mod m). We track prefix remainder frequencies and count valid pairs efficiently.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table (Optimal)	O(n)	O(min(n, modulo))	Use prefix sums and hash map to count subarrays in one pass
Brute Force (Nested Loops)	O(n²)	O(1)	Check every possible subarray by counting special elements

One-Pass Hash Table (Optimal) — Algorithm Steps

Initialize hash map with {0: 1} to handle subarrays starting from index 0
Iterate through array, maintaining prefix sum of special elements
Calculate current prefix remainder: prefix_sum % modulo
Find target remainder that would make subarray count % modulo == k
Add count of target remainder from hash map to result
Update hash map with current remainder

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with hash map {0: 1} for empty prefix

Process element

Update prefix sum if element is special

Calculate remainders

Find current and target remainders

Count matches

Add count of target remainder to result

Update map

Increment count of current remainder

Code -

solution.c — C

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

#define MAX_MODULO 1000

long long countInterestingSubarrays(int* nums, int n, int modulo, int k) {
    int prefixCount[MAX_MODULO] = {0};
    prefixCount[0] = 1;
    int prefixSum = 0;
    long long result = 0;
    
    for (int i = 0; i < n; i++) {
        if (nums[i] % modulo == k) {
            prefixSum++;
        }
        
        int currentRemainder = prefixSum % modulo;
        int targetRemainder = (currentRemainder - k + modulo) % modulo;
        
        result += prefixCount[targetRemainder];
        prefixCount[currentRemainder]++;
    }
    
    return result;
}

int main() {
    int n;
    scanf("%d", &n);
    int* nums = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        scanf("%d", &nums[i]);
    }
    int modulo, k;
    scanf("%d %d", &modulo, &k);
    printf("%lld\n", countInterestingSubarrays(nums, n, modulo, k));
    free(nums);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

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

✓ Linear Growth

Space Complexity

O(min(n, modulo))

Hash map stores at most modulo different remainders

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
1 ≤ modulo ≤ 10⁹
0 ≤ k < modulo

28.5K Views

Medium Frequency

~25 min Avg. Time

890 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

One-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler