K Divisible Elements Subarrays - Practice Coding Problems

K Divisible Elements Subarrays - Problem

You're given an integer array nums and two integers k and p. Your task is to find the number of distinct subarrays that contain at most k elements divisible by p.

A subarray is any contiguous sequence of elements from the original array. Two subarrays are considered distinct if they have different lengths OR if there's at least one position where their elements differ.

Example: In array [2, 3, 3, 2, 2] with k=2, p=2, we need to count subarrays with at most 2 elements divisible by 2. The subarray [2, 3] starting at index 0 is different from [2, 3] starting at index 2, even though they have the same elements, because they occupy different positions in the original array.

This problem combines subarray enumeration with constraint checking and requires efficient duplicate detection using hash-based techniques.

Input & Output

example_1.py — Basic Case

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

› Output: 11

💡 Note: Valid subarrays with at most 2 elements divisible by 2: [2],[3],[3],[2],[2],[2,3],[3,3],[3,2],[2,2],[2,3,3],[3,3,2]. Even though some have same values, they're at different positions so they're distinct.

example_2.py — Edge Case k=0

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

› Output: 3

💡 Note: Only subarrays with 0 elements divisible by 2 are valid: [1],[3],[1,3]. All others contain at least one even number.

example_3.py — All Elements Divisible

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

› Output: 3

💡 Note: Each single element forms a valid subarray: [2],[4],[6]. All longer subarrays exceed k=1 limit.

Visualization

Tap to expand

Understanding the Visualization

Choose Starting Point

Pick a starting position on the shelf (array index)

Extend Section

Add books one by one, counting books of target genre

Check Constraint

If genre count ≤ k, this section is valid

Record Unique Sections

Use hash set to avoid counting duplicate sections

Early Stop

If genre count > k, stop extending (no point continuing)

Key Takeaway

🎯 Key Insight: By building subarrays incrementally and using early termination, we avoid unnecessary work while maintaining efficient duplicate detection through hashing.

Time & Space Complexity

Time Complexity

⏱️

O(n²·L)

O(n²) subarray pairs, O(L) average length for string conversion, but with early termination

⚠ Quadratic Growth

Space Complexity

O(n²·L)

Hash set stores up to O(n²) strings, each of average length L

⚠ Quadratic Space

Constraints

1 ≤ nums.length ≤ 200
1 ≤ nums[i], p ≤ 200
1 ≤ k ≤ nums.length
All test cases are generated such that the answer is at most 10⁴

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal approach uses incremental subarray building with a hash set for duplicate detection. For each starting position, we extend the subarray one element at a time while maintaining a count of divisible elements. Key optimizations include early termination when the divisible count exceeds k and O(1) duplicate checking using string hashing.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force with Set Storage	O(n³)	O(n³)	Generate all subarrays, check divisibility constraint, store in set for uniqueness
Optimized Hash Set (Incremental)	O(n²·L)	O(n²·L)	Generate subarrays incrementally while maintaining divisibility count and using hash set for deduplication

Brute Force with Set Storage — Algorithm Steps

Iterate through all possible starting positions i
For each i, iterate through all ending positions j ≥ i
Extract subarray nums[i:j+1] and count elements divisible by p
If count ≤ k, convert subarray to tuple and add to set
Return size of the set

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Position

Choose starting index i

End Position

For each i, try all ending indices j ≥ i

Extract & Check

Extract subarray and count divisible elements

Store if Valid

If count ≤ k, add to set for uniqueness

Code -

solution.c — C

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

#define MAX_SUBARRAYS 10000
#define MAX_SUBARRAY_LEN 1000

int distinctSubarraysWithAtMostKDiv(int* nums, int numsSize, int k, int p) {
    char subarrays[MAX_SUBARRAYS][MAX_SUBARRAY_LEN];
    int count = 0;
    
    for (int i = 0; i < numsSize; i++) {
        for (int j = i; j < numsSize; j++) {
            char subarray[MAX_SUBARRAY_LEN] = "";
            int divCount = 0;
            
            for (int idx = i; idx <= j; idx++) {
                char temp[20];
                sprintf(temp, "%d,", nums[idx]);
                strcat(subarray, temp);
                if (nums[idx] % p == 0) divCount++;
            }
            
            if (divCount <= k) {
                int found = 0;
                for (int s = 0; s < count; s++) {
                    if (strcmp(subarrays[s], subarray) == 0) {
                        found = 1;
                        break;
                    }
                }
                if (!found && count < MAX_SUBARRAYS) {
                    strcpy(subarrays[count], subarray);
                    count++;
                }
            }
        }
    }
    
    return count;
}

int main() {
    int nums[] = {2, 3, 3, 2, 2};
    int k = 2, p = 2;
    printf("%d\n", distinctSubarraysWithAtMostKDiv(nums, 5, k, p));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) pairs of start/end positions, O(n) to extract and process each subarray

⚠ Quadratic Growth

Space Complexity

O(n³)

In worst case, we store O(n²) subarrays, each taking O(n) space

⚠ Quadratic Space

Constraints

1 ≤ nums.length ≤ 200
1 ≤ nums[i], p ≤ 200
1 ≤ k ≤ nums.length
All test cases are generated such that the answer is at most 10⁴

23.5K Views

Medium Frequency

~25 min Avg. Time

980 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

Brute Force with Set Storage — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler