Subarrays with K Different Integers - Practice Coding Problems

Subarrays with K Different Integers - Problem

You're given an integer array nums and an integer k. Your task is to count the number of "good" subarrays in the array.

A subarray is considered good if it contains exactly k different integers. For example, the subarray [1,2,3,1,2] has exactly 3 different integers: 1, 2, and 3.

Remember: A subarray is a contiguous part of an array, meaning all elements must be adjacent to each other in the original array.

Goal: Return the total count of all good subarrays.

Example: If nums = [1,2,1,2,3] and k = 2, then subarrays like [1,2], [2,1], [1,2,1], [2,1,2] are all good because they contain exactly 2 different integers.

Input & Output

example_1.py — Basic Case

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

› Output: 7

💡 Note: Subarrays with exactly 2 distinct integers: [1,2], [2,1], [1,2,1], [2,1,2], [1,2,1,2], [2,3], [1,2,3] (only the last 6 positions). Total = 7

example_2.py — Single Element

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

› Output: 3

💡 Note: Subarrays with exactly 3 distinct integers: [1,2,1,3], [2,1,3], [1,3,4]. Each contains exactly 3 different numbers.

example_3.py — Edge Case

$ Input: nums = [1,1,1], k = 1

› Output: 6

💡 Note: All subarrays contain exactly 1 distinct integer: [1], [1], [1], [1,1], [1,1], [1,1,1]. Total = 3 + 2 + 1 = 6

Visualization

Tap to expand

Understanding the Visualization

Setup Two Counters

Create helper function to count subarrays with 'at most k' distinct integers

Expand Window

Move right pointer, add new elements to frequency map

Contract When Needed

If distinct count > k, move left pointer and update frequencies

Count Valid Subarrays

For each position, add (right - left + 1) to total count

Apply Formula

Return atMost(k) - atMost(k-1) to get exactly k distinct integers

Key Takeaway

🎯 Key Insight: The brilliant transformation 'exactly k = at most k - at most k-1' converts a complex counting problem into two simple sliding window problems, achieving O(n) time complexity!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is visited at most twice (once by right pointer, once by left pointer) in each of the two helper function calls

✓ Linear Growth

Space Complexity

O(k)

Hash map stores at most k distinct elements and their frequencies

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 2 × 10⁴
1 ≤ nums[i], k ≤ nums.length
All integers in nums are positive

Asked in

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

The optimal solution uses the sliding window technique with a clever transformation: exactly k = at_most(k) - at_most(k-1). This reduces the hard problem of counting subarrays with exactly k distinct integers into two easier problems of counting subarrays with at most k distinct integers. Time complexity: O(n), Space complexity: O(k).

Common Approaches

Approach	Time	Space	Notes
✓ Sliding Window (Optimal)	O(n)	O(k)	Transform problem to: 'at most k' - 'at most k-1' using sliding window
Brute Force (Check All Subarrays)	O(n²)	O(k)	Check every possible subarray and count distinct integers

Sliding Window (Optimal) — Algorithm Steps

Create helper function to count subarrays with 'at most k' distinct integers
Use sliding window technique with hash map to track element frequencies
Expand window by moving right pointer, contract by moving left pointer
Return at_most(k) - at_most(k-1) to get exactly k distinct integers

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize window

Start with left=0, right=0, empty frequency map

Expand window

Move right pointer, add elements to frequency map

Contract if needed

If more than k distinct, move left pointer

Count subarrays

Add (right - left + 1) to total count

Code -

solution.c — C

int atMostK(int* nums, int numsSize, int k) {
    if (k == 0) return 0;
    
    int count = 0;
    int left = 0;
    int freq[20001] = {0};
    int distinctCount = 0;
    
    for (int right = 0; right < numsSize; right++) {
        // Expand window
        if (freq[nums[right]] == 0) {
            distinctCount++;
        }
        freq[nums[right]]++;
        
        // Contract window if we have more than k distinct
        while (distinctCount > k) {
            freq[nums[left]]--;
            if (freq[nums[left]] == 0) {
                distinctCount--;
            }
            left++;
        }
        
        // All subarrays ending at 'right' with at most k distinct
        count += right - left + 1;
    }
    
    return count;
}

int subarraysWithKDistinct(int* nums, int numsSize, int k) {
    return atMostK(nums, numsSize, k) - atMostK(nums, numsSize, k - 1);
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is visited at most twice (once by right pointer, once by left pointer) in each of the two helper function calls

✓ Linear Growth

Space Complexity

O(k)

Hash map stores at most k distinct elements and their frequencies

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 2 × 10⁴
1 ≤ nums[i], k ≤ nums.length
All integers in nums are positive

89.4K Views

Medium-High Frequency

~25 min Avg. Time

2.2K 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

Sliding Window (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler