Distinct Numbers in Each Subarray - Practice Coding Problems

Distinct Numbers in Each Subarray - Problem

Given an integer array nums of length n and an integer k, you need to analyze every possible contiguous subarray of size k and count how many distinct elements each subarray contains.

Your task is to return an array ans where ans[i] represents the number of unique elements in the subarray starting at index i and ending at index i + k - 1.

For example, if nums = [1, 2, 1, 3, 4] and k = 3, you would examine:

Subarray [1, 2, 1] → 2 distinct elements
Subarray [2, 1, 3] → 3 distinct elements
Subarray [1, 3, 4] → 3 distinct elements

So the result would be [2, 3, 3].

Input & Output

example_1.py — Basic Case

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

› Output: [2, 3, 3]

💡 Note: Subarray [1,2,1] has 2 distinct elements: {1,2}. Subarray [2,1,3] has 3 distinct elements: {1,2,3}. Subarray [1,3,4] has 3 distinct elements: {1,3,4}.

example_2.py — All Same Elements

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

› Output: [1, 1, 1]

💡 Note: All subarrays of size 2 contain only the element 1, so each has 1 distinct element.

example_3.py — All Different Elements

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

› Output: [3, 3, 3]

💡 Note: Each subarray [1,2,3], [2,3,4], [3,4,5] contains 3 completely different elements.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ k ≤ nums.length
1 ≤ nums[i] ≤ 10⁵

Visualization

Tap to expand

Understanding the Visualization

Set Initial Window

Position the window over the first k elements and count distinct items

Slide Window Right

Move window one position: remove leftmost element from frequency count

Add New Element

Include the new rightmost element in frequency count

Update Counter

The size of frequency map gives us the distinct count

Repeat Process

Continue sliding until all subarrays are processed

Key Takeaway

🎯 Key Insight: By maintaining a frequency map and sliding the window efficiently, we avoid recalculating overlapping information. Each element is processed exactly twice (once when entering, once when exiting), achieving optimal O(n) time complexity.

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses a sliding window technique combined with a frequency map. Instead of recalculating distinct elements for each subarray, we maintain a frequency map of the current window and slide it efficiently by removing the leftmost element and adding the new rightmost element. This achieves O(n) time complexity compared to the brute force O(n*k) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n*k)	O(k)	For each subarray, count distinct elements using a set
Sliding Window with Hash Map (Optimal)	O(n)	O(k)	Use sliding window technique with frequency map to track distinct elements efficiently

Brute Force (Nested Loops) — Algorithm Steps

Initialize result array of size n-k+1
For each starting position i from 0 to n-k
Create a new set for the current subarray
Add all k elements to the set
Store the set size in result[i]
Return the result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with the first subarray of size k

Count Distinct

Add all elements to a set and count unique values

Move Window

Move to next starting position and repeat

Repeat

Continue until all subarrays are processed

Code -

solution.c — C

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

int* distinctNumbersInSubarrays(int* nums, int numsSize, int k, int* returnSize) {
    *returnSize = numsSize - k + 1;
    int* result = (int*)malloc((*returnSize) * sizeof(int));
    
    // Check each subarray of size k
    for (int i = 0; i <= numsSize - k; i++) {
        // Count distinct elements using simple array approach
        int distinct[1001] = {0};  // Assuming elements are <= 1000
        int count = 0;
        
        for (int j = i; j < i + k; j++) {
            if (distinct[nums[j]] == 0) {
                distinct[nums[j]] = 1;
                count++;
            }
        }
        result[i] = count;
    }
    
    return result;
}

int main() {
    int nums[1000];
    int numsSize = 0;
    int k;
    
    // Read input
    char line[10000];
    fgets(line, sizeof(line), stdin);
    char* token = strtok(line, " ");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, " ");
    }
    
    scanf("%d", &k);
    
    int returnSize;
    int* result = distinctNumbersInSubarrays(nums, numsSize, k, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(", ");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n*k)

We iterate through n-k+1 subarrays, and for each subarray we process k elements

✓ Linear Growth

Space Complexity

O(k)

We use a set of at most k elements for each subarray calculation

✓ Linear Space

58.2K Views

High Frequency

~18 min Avg. Time

1.8K 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 (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler