Find the Median of the Uniqueness Array - Practice Coding Problems

Find the Median of the Uniqueness Array - Problem

Imagine you have an array of integers, and you want to explore the uniqueness of every possible subarray within it. For each subarray, count how many distinct elements it contains - this creates what we call a uniqueness array.

Given an integer array nums, your task is to:

Calculate the number of distinct elements for every possible subarray nums[i..j] where 0 ≤ i ≤ j < nums.length
Sort these uniqueness counts in non-decreasing order
Find the median of this sorted uniqueness array

Example: For nums = [1, 2, 3], the subarrays and their distinct counts are:

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

The uniqueness array becomes [1,1,1,2,2,3], and the median is 1 (the smaller middle value).

Note: When there are two middle elements, choose the smaller one.

Input & Output

example_1.py — Basic Case

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

› Output: 1

💡 Note: Subarrays: [1]→1, [2]→1, [3]→1, [1,2]→2, [2,3]→2, [1,2,3]→3. Uniqueness array: [1,1,1,2,2,3]. Median of 6 elements is the smaller of positions 3,4 = 1.

example_2.py — Duplicates

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

› Output: 2

💡 Note: Many subarrays will have repeated elements, so uniqueness values will be lower. The median uniqueness considering all 15 subarrays is 2.

example_3.py — Single Element

$ Input: nums = [1]

› Output: 1

💡 Note: Only one subarray [1] with 1 distinct element. The uniqueness array is [1], so median is 1.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁵
The uniqueness array will always have an odd number of elements or use the smaller middle value for even length

Visualization

Tap to expand

Understanding the Visualization

Survey All Sections

Look at every possible continuous shelf section [i,j] and count unique book genres

Collect Diversity Scores

Record the diversity (distinct genres) for each section: some sections have 1 genre, others have 2, 3, etc.

Find Typical Diversity

Sort all diversity scores and find the median - this represents the 'typical' diversity level

Optimize with Smart Counting

Instead of checking every section manually, use binary search to guess the median and verify efficiently

Key Takeaway

🎯 Key Insight: Instead of manually checking every shelf section (O(n³)), we can binary search for the median diversity level and use sliding window to efficiently verify our guess (O(n² log n))!

Asked in

G Google 32 f Meta 28 a Amazon 15 ⊞ Microsoft 12

The optimal solution uses binary search on the median value combined with sliding window technique to count subarrays efficiently. Instead of generating all O(n²) uniqueness values explicitly, we binary search for the answer and verify each candidate by counting how many subarrays have ≤ k distinct elements. This reduces time complexity from O(n³) to O(n² log n) while using only O(n) space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Subarrays)	O(n³)	O(n²)	Generate all subarrays, count distinct elements in each, sort, and find median
Binary Search + Sliding Window (Optimal)	O(n² log n)	O(n)	Binary search on the median value, use sliding window to count subarrays efficiently

Brute Force (Generate All Subarrays) — Algorithm Steps

Generate all possible subarrays nums[i..j] for 0 ≤ i ≤ j < n
For each subarray, use a hash set to count distinct elements
Store all uniqueness counts in an array
Sort the uniqueness array
Return the median (middle element, or smaller of two middle elements)

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subarrays

Create all possible subarrays [i,j] where i ≤ j

Count Distinct

Use hash set to count unique elements in each subarray

Collect Results

Store all uniqueness counts in an array

Sort and Find Median

Sort the uniqueness array and return middle element

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int medianOfUniquenessArray(int* nums, int numsSize) {
    int* uniqueness = (int*)malloc(numsSize * (numsSize + 1) / 2 * sizeof(int));
    int idx = 0;
    
    // Generate all subarrays and count distinct elements
    for (int i = 0; i < numsSize; i++) {
        int* seen = (int*)calloc(100001, sizeof(int)); // assuming nums[i] <= 100000
        int distinct_count = 0;
        for (int j = i; j < numsSize; j++) {
            if (seen[nums[j]] == 0) {
                seen[nums[j]] = 1;
                distinct_count++;
            }
            uniqueness[idx++] = distinct_count;
        }
        free(seen);
    }
    
    // Sort and find median
    qsort(uniqueness, idx, sizeof(int), compare);
    int result = uniqueness[(idx - 1) / 2];
    free(uniqueness);
    return result;
}

int main() {
    int nums[1000];
    int n = 0;
    int num;
    while (scanf("%d", &num) == 1) {
        nums[n++] = num;
        if (getchar() == '\n') break;
    }
    printf("%d\n", medianOfUniquenessArray(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) subarrays × O(n) to count distinct elements in each subarray

⚠ Quadratic Growth

Space Complexity

O(n²)

Storage for all n*(n+1)/2 uniqueness values plus temporary hash sets

⚠ Quadratic Space

23.4K Views

Medium Frequency

~35 min Avg. Time

856 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 (Generate All Subarrays) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler