Count Complete Subarrays in an Array - Practice Coding Problems

Count Complete Subarrays in an Array - Problem

Imagine you have a colorful array of positive integers, and you're on a mission to find all the "complete" subarrays - those special contiguous segments that contain the exact same variety of distinct elements as the entire array!

A subarray is considered complete when:

It's a contiguous (unbroken) sequence from the original array
The number of distinct elements in the subarray equals the number of distinct elements in the whole array

Your Goal: Count how many complete subarrays exist in the given array.

Example: If nums = [1,3,1,2,2], the whole array has 3 distinct elements (1, 2, 3). Any subarray with exactly these 3 distinct elements is complete!

Input & Output

example_1.py — Basic Case

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

› Output: 4

💡 Note: The array has 3 distinct elements: {1,2,3}. Complete subarrays are: [1,3,1,2], [1,3,1,2,2], [3,1,2], [3,1,2,2]. Each contains exactly 3 distinct elements.

example_2.py — All Same Elements

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

› Output: 10

💡 Note: Only 1 distinct element (5) exists. Every subarray is complete since they all contain exactly 1 distinct element. Total subarrays = 4+3+2+1 = 10.

example_3.py — All Different Elements

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

› Output: 1

💡 Note: Array has 3 distinct elements. Only the entire array [1,2,3] contains all 3 distinct elements, so there's exactly 1 complete subarray.

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 1000
All elements are positive integers

Visualization

Tap to expand

Understanding the Visualization

Count Art Types

First, catalog all different types of artwork in your collection

Sliding Exhibition

Use a sliding window to find rooms that showcase every art type

Count Valid Rooms

Once you have a complete room, count all extensions that remain complete

Key Takeaway

🎯 Key Insight: Instead of checking every possible subarray individually, we use sliding window to efficiently identify complete regions and count all valid extensions at once, reducing complexity from O(n³) to O(n)!

Asked in

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

The optimal solution uses a sliding window technique with hash map to count complete subarrays in O(n) time. Key insight: once we find a complete window, we can count multiple valid subarrays ending at the current position efficiently, avoiding redundant work of the brute force approach.

Common Approaches

Approach	Time	Space	Notes
✓ Sliding Window with Hash Map (Optimal)	O(n)	O(k)	Use sliding window technique to efficiently count complete subarrays
Brute Force (Nested Loops)	O(n³)	O(n)	Check every possible subarray and count distinct elements

Sliding Window with Hash Map (Optimal) — Algorithm Steps

Count total distinct elements in the array
Use sliding window with left and right pointers
Expand right pointer and track element frequencies
When window has all distinct elements, count valid subarrays
Slide left pointer to find the minimum valid window
Add count of all subarrays ending at current right position

Visualization

Tap to expand

Step-by-Step Walkthrough

Expand Right

Expand window until it contains all distinct elements

Count Valid

Once complete, count all subarrays ending at current position

Contract Left

Contract from left while maintaining completeness

Code -

solution.c — C

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

int countCompleteSubarrays(int* nums, int numsSize) {
    // Count total distinct elements
    int distinct[1001] = {0};
    int totalDistinct = 0;
    for (int i = 0; i < numsSize; i++) {
        if (!distinct[nums[i]]) {
            distinct[nums[i]] = 1;
            totalDistinct++;
        }
    }
    
    int count = 0;
    int left = 0;
    int freq[1001] = {0};
    int currentDistinct = 0;
    
    for (int right = 0; right < numsSize; right++) {
        // Add current element to window
        if (freq[nums[right]] == 0) {
            currentDistinct++;
        }
        freq[nums[right]]++;
        
        // Shrink window from left while maintaining all distinct elements
        while (currentDistinct == totalDistinct) {
            // All subarrays from current left to end are complete
            count += numsSize - right;
            
            // Remove leftmost element
            freq[nums[left]]--;
            if (freq[nums[left]] == 0) {
                currentDistinct--;
            }
            left++;
        }
    }
    
    return count;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass with sliding window, each element visited at most twice

✓ Linear Growth

Space Complexity

O(k)

O(k) space for hash map where k is number of distinct elements

✓ Linear Space

24.7K Views

Medium Frequency

~18 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

Sliding Window with Hash Map (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler