Count of Interesting Subarrays

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 the following condition holds:

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

Return an integer denoting the count of interesting subarrays.

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

Input & Output

Example 1 — Basic Case

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

› Output: 3

💡 Note: Subarrays: [4] has 1 element where 4%3=1, and 1%3=1 ✓. [2,4] has 1 element where 4%3=1, and 1%3=1 ✓. [3,2,4] has 1 element where 4%3=1, and 1%3=1 ✓. Total: 3 interesting subarrays.

Example 2 — Multiple Valid Elements

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

› Output: 4

💡 Note: Looking for elements where nums[i]%3=2: positions 0,2,3,5 have value 2. We need subarrays where count%3=2. Subarrays with exactly 2 or 5 such elements work.

Example 3 — No Valid Subarrays

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

› Output: 0

💡 Note: No element satisfies nums[i]%4=3, so no subarray can have count%4=3. Result is 0.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 12 M Microsoft 8 A Amazon 6

The key insight is to transform this into a prefix sum problem where we track remainder patterns. Convert the array to binary (1 if nums[i] % modulo == k, else 0), then use hash map to count subarrays efficiently. Best approach is prefix sum with hash map. Time: O(n), Space: O(min(n, modulo))

Common Approaches

✓ Brute Force - Check All Subarrays

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

For each possible subarray, count how many elements satisfy nums[i] % modulo == k, then check if that count % modulo == k.

Prefix Sum with Hash Map

⏱️ Time: O(n) Space: O(min(n, modulo))

Convert the problem to counting prefix sums. Track how many elements satisfy the condition as we go, then use hash map to count subarrays with the right remainder pattern.

Brute Force - Check All Subarrays — Algorithm Steps

Generate all possible subarrays
For each subarray, count elements where nums[i] % modulo == k
Check if count % modulo == k

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subarrays

Create all possible contiguous subarrays

Count Valid Elements

For each subarray, count elements where nums[i] % modulo == k

Check Condition

Verify if count % modulo == k

Code -

solution.c — C

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

long long solution(int* nums, int numsSize, int modulo, int k) {
    long long result = 0;
    
    // Check all possible subarrays
    for (int i = 0; i < numsSize; i++) {
        for (int j = i; j < numsSize; j++) {
            // Count elements in subarray [i, j] where nums[x] % modulo == k
            int count = 0;
            for (int x = i; x <= j; x++) {
                if (nums[x] % modulo == k) {
                    count++;
                }
            }
            
            // Check if count % modulo == k
            if (count % modulo == k) {
                result++;
            }
        }
    }
    
    return result;
}

int main() {
    char line[100000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array - remove brackets and split by comma
    int nums[100000];
    int numsSize = 0;
    
    // Find the content between brackets
    char* start = strchr(line, '[');
    char* end = strchr(line, ']');
    if (start && end && start < end) {
        start++; // Skip opening bracket
        *end = '\0'; // Null terminate at closing bracket
        
        // Parse comma-separated numbers
        char* token = strtok(start, ",");
        while (token != NULL && numsSize < 100000) {
            // Skip whitespace
            while (*token == ' ') token++;
            nums[numsSize++] = atoi(token);
            token = strtok(NULL, ",");
        }
    }
    
    int modulo, k;
    scanf("%d", &modulo);
    scanf("%d", &k);
    
    long long result = solution(nums, numsSize, modulo, k);
    printf("%lld\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops: O(n²) subarrays × O(n) to count each

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra variables

⚡ Linearithmic Space

12.5K Views

Medium Frequency

~25 min Avg. Time

456 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