K Divisible Elements Subarrays

K Divisible Elements Subarrays - Problem

Given an integer array nums and two integers k and p, return the number of distinct subarrays, which have at most k elements that are divisible by p.

Two arrays nums1 and nums2 are said to be distinct if:

They are of different lengths, or
There exists at least one index i where nums1[i] != nums2[i].

A subarray is defined as a non-empty contiguous sequence of elements in an array.

Input & Output

Example 1 — Basic Case

$ Input: nums = [2,3,3,2], k = 2, p = 3

› Output: 8

💡 Note: Subarrays with at most 2 elements divisible by 3: Starting from index 0: [2], [2,3], [2,3,3], [2,3,3,2]. Starting from index 1: [3], [3,3], [3,3,2]. Starting from index 2: [3], [3,2]. Starting from index 3: [2]. After removing duplicates: [2], [2,3], [2,3,3], [2,3,3,2], [3], [3,3], [3,3,2], [3,2] = 8 distinct subarrays.

Example 2 — All Valid

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

› Output: 10

💡 Note: All elements divisible by 1, k=4 allows all. All 10 possible subarrays are valid: [1], [1,2], [1,2,3], [1,2,3,4], [2], [2,3], [2,3,4], [3], [3,4], [4].

Example 3 — No Divisible Elements

$ Input: nums = [1,9,8,3], k = 1, p = 2

› Output: 10

💡 Note: No elements divisible by 2, so all subarrays are valid: [1], [1,9], [1,9,8], [1,9,8,3], [9], [9,8], [9,8,3], [8], [8,3], [3] = 10 distinct.

Constraints

1 ≤ nums.length ≤ 200
1 ≤ nums[i] ≤ 200
1 ≤ k ≤ nums.length
1 ≤ p ≤ 200

Visualization

Tap to expand

Asked in

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

The key insight is to generate all possible subarrays while tracking divisible elements, then use a set to count unique subarrays. The brute force approach stores complete subarrays in a set, while the optimized version uses rolling hash for space efficiency. Best approach is rolling hash with Time: O(n²), Space: O(n²).

Common Approaches

✓ Brute Force with Set

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

For each starting position, extend the subarray one element at a time. Count elements divisible by p, and if count ≤ k, add subarray to set. The set automatically handles uniqueness.

Rolling Hash Optimization

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

Instead of storing complete subarrays as strings, use a polynomial rolling hash to represent each subarray uniquely. This significantly reduces space complexity while maintaining the same logic flow.

Brute Force with Set — Algorithm Steps

Step 1: Iterate through all possible starting positions i
Step 2: For each i, extend subarray from i to j, counting divisible elements
Step 3: If divisible count ≤ k, add subarray to set
Step 4: Return size of set

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate

Create all possible subarrays

Validate

Count divisible elements ≤ k

Store

Add valid subarrays to set for uniqueness

Code -

solution.c — C

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

#define MAX_SUBARRAYS 10000
#define MAX_STR_LEN 1000

int solution(int* nums, int numsSize, int k, int p) {
    char subarrays[MAX_SUBARRAYS][MAX_STR_LEN];
    int count = 0;
    
    for (int i = 0; i < numsSize; i++) {
        int divisibleCount = 0;
        char subarray[MAX_STR_LEN] = "";
        
        for (int j = i; j < numsSize; j++) {
            if (nums[j] % p == 0) {
                divisibleCount++;
            }
            
            if (divisibleCount <= k) {
                if (j > i) strcat(subarray, ",");
                char num[20];
                sprintf(num, "%d", nums[j]);
                strcat(subarray, num);
                
                // Check if subarray already exists
                int exists = 0;
                for (int c = 0; c < count; c++) {
                    if (strcmp(subarrays[c], subarray) == 0) {
                        exists = 1;
                        break;
                    }
                }
                
                if (!exists) {
                    strcpy(subarrays[count], subarray);
                    count++;
                }
            } else {
                break;
            }
        }
    }
    
    return count;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[100];
    int numsSize = 0;
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    int k, p;
    scanf("%d", &k);
    scanf("%d", &p);
    
    int result = solution(nums, numsSize, k, p);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Nested loops O(n²) to generate subarrays, plus O(n) to convert each to string

⚠ Quadratic Growth

Space Complexity

O(n³)

Set stores up to O(n²) subarrays, each taking O(n) space as string

⚠ Quadratic Space

32.5K Views

Medium Frequency

~25 min Avg. Time

847 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 with Set — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler