Count Complete Subarrays in an Array - Practice Coding Problems

Count Complete Subarrays in an Array - Problem

You are given an array nums consisting of positive integers.

We call a subarray of an array complete if the following condition is satisfied:

The number of distinct elements in the subarray is equal to the number of distinct elements in the whole array.

Return the number of complete subarrays.

A subarray is a contiguous non-empty part of an array.

Input & Output

Example 1 — Basic Case

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

› Output: 4

💡 Note: Complete subarrays are [1,3,1,2], [1,3,1,2,2], [3,1,2], [3,1,2,2]. All have 3 distinct elements like the whole array {1,2,3}.

Example 2 — All Same Elements

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

› Output: 15

💡 Note: Only 1 distinct element (2) in whole array. All 15 possible subarrays have exactly 1 distinct element, so all are complete.

Example 3 — All Different Elements

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

› Output: 10

💡 Note: Only 1 distinct element (5). All subarrays: [5], [5], [5], [5], [5,5], [5,5], [5,5], [5,5,5], [5,5,5], [5,5,5,5] = 10 total subarrays.

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 2000

Visualization

Tap to expand

Understanding the Visualization

Input Analysis

Array [1,3,1,2,2] has 3 distinct elements: {1,2,3}

Find Complete

Search subarrays with exactly 3 distinct elements

Count Result

Found 4 complete subarrays total

Key Takeaway

🎯 Key Insight: Once a subarray contains all distinct elements, extending it right keeps it complete

Asked in

G Google 35 a Amazon 28 M Microsoft 22 🍎 Apple 18

The key insight is that a complete subarray contains the same number of distinct elements as the entire array. The sliding window approach optimizes by recognizing that once a subarray becomes complete, all its extensions to the right remain complete. Best approach uses sliding window with Time: O(n²), Space: O(k) where k is number of distinct elements.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force - Check All Subarrays	O(n³)	O(k)	Generate all possible subarrays and count distinct elements in each
Sliding Window Optimization	O(n²)	O(k)	Use sliding window to find all valid subarrays efficiently

Brute Force - Check All Subarrays — Algorithm Steps

Count total distinct elements in the array
For each starting index i, iterate through ending indices j
For each subarray [i...j], count distinct elements using a set
If distinct count equals total, increment result

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Total

Find total distinct elements: 3

Check All

Examine each subarray [i,j] and count distinct

Count Complete

Increment result when distinct count equals 3

Code -

solution.c — C

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

int solution(int* nums, int n) {
    int totalDistinct = 0;
    int maxVal = 0;
    for (int i = 0; i < n; i++) {
        if (nums[i] > maxVal) maxVal = nums[i];
    }
    
    int* seen = (int*)calloc(maxVal + 1, sizeof(int));
    for (int i = 0; i < n; i++) {
        if (!seen[nums[i]]) {
            seen[nums[i]] = 1;
            totalDistinct++;
        }
    }
    free(seen);
    
    int count = 0;
    for (int i = 0; i < n; i++) {
        int* distinctSet = (int*)calloc(maxVal + 1, sizeof(int));
        int distinctCount = 0;
        for (int j = i; j < n; j++) {
            if (!distinctSet[nums[j]]) {
                distinctSet[nums[j]] = 1;
                distinctCount++;
            }
            if (distinctCount == totalDistinct) {
                count++;
            }
        }
        free(distinctSet);
    }
    
    return count;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int n = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    printf("%d\n", solution(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Nested loops O(n²) to generate subarrays, O(n) to count distinct elements in each

⚠ Quadratic Growth

Space Complexity

O(k)

Hash set stores at most k distinct elements where k is number of unique elements

✓ Linear Space

23.4K Views

Medium Frequency

~25 min Avg. Time

892 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 - Check All Subarrays — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler