Distinct Numbers in Each Subarray

Distinct Numbers in Each Subarray - Problem

You are given an integer array nums of length n and an integer k. Your task is to find the number of distinct elements in every subarray of size k within nums.

Return an array ans such that ans[i] is the count of distinct elements in nums[i..(i + k - 1)] for each index 0 <= i < n - k.

Example: For nums = [1,2,1,3,4,2,3] and k = 4, the subarrays of size 4 are:

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

So the answer is [3,4,4,3].

Input & Output

Example 1 — Basic Case

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

› Output: [3,4,4,3]

💡 Note: Subarrays: [1,2,1,3]→3 distinct, [2,1,3,4]→4 distinct, [1,3,4,2]→4 distinct, [3,4,2,3]→3 distinct

Example 2 — Minimum Size

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

› Output: [2,2]

💡 Note: Subarrays: [1,2]→2 distinct, [2,3]→2 distinct

Example 3 — All Same Elements

$ Input: nums = [5,5,5,5], k = 3

› Output: [1,1]

💡 Note: Subarrays: [5,5,5]→1 distinct, [5,5,5]→1 distinct

Constraints

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

Visualization

Tap to expand

Asked in

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

The sliding window with hash map approach is optimal. Track element frequencies as the window slides - when adding an element, increment its frequency (increase distinct count if frequency was 0). When removing, decrement frequency (decrease distinct count if frequency becomes 0). Time: O(n), Space: O(k)

Common Approaches

✓ Brute Force

⏱️ Time: O(n×k) Space: O(k)

Iterate through all possible subarrays of size k, and for each subarray, use a set to count the number of distinct elements.

Sliding Window with Hash Map

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

Use a hash map to track element frequencies in the current window. As the window slides, add the new element and remove the old element while maintaining the count of distinct elements.

Brute Force — Algorithm Steps

Step 1: Iterate through each starting position
Step 2: For each position, create a set from the k elements
Step 3: Count distinct elements using set size

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with first subarray of size k

Count Distinct

Use set to find unique elements

Slide Window

Move to next subarray and repeat

Code -

solution.c — C

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

#define MAX_VAL 200001

int* solution(int* nums, int numsSize, int k, int* returnSize) {
    *returnSize = numsSize - k + 1;
    if (*returnSize <= 0) {
        *returnSize = 0;
        return NULL;
    }
    
    int* result = (int*)malloc(*returnSize * sizeof(int));
    int freqMap[MAX_VAL] = {0};
    int distinctCount = 0;
    
    // Initialize first window
    for (int i = 0; i < k; i++) {
        int idx = nums[i] + 100000; // Offset for negative numbers
        if (freqMap[idx] == 0) {
            distinctCount++;
        }
        freqMap[idx]++;
    }
    
    result[0] = distinctCount;
    
    // Slide the window
    for (int i = k; i < numsSize; i++) {
        // Add new element
        int newIdx = nums[i] + 100000;
        if (freqMap[newIdx] == 0) {
            distinctCount++;
        }
        freqMap[newIdx]++;
        
        // Remove old element
        int oldIdx = nums[i - k] + 100000;
        freqMap[oldIdx]--;
        if (freqMap[oldIdx] == 0) {
            distinctCount--;
        }
        
        result[i - k + 1] = distinctCount;
    }
    
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple array parsing
    int nums[1000];
    int numsSize = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, "[,]");
    }
    
    int k;
    scanf("%d", &k);
    
    int returnSize;
    int* result = solution(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)

For each of (n-k+1) subarrays, we process k elements

✓ Linear Growth

Space Complexity

O(k)

Set stores up to k elements for each subarray

✓ Linear Space

23.4K Views

Medium Frequency

~15 min Avg. Time

890 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler