Number of Unique Categories - Practice Coding Problems

Number of Unique Categories - Problem

Number of Unique Categories

You're working as a data analyst for a large company that needs to categorize n items (numbered from 0 to n-1). Each item belongs to exactly one category, but you don't know the categories directly.

Instead, you have access to a CategoryHandler object with a special method:

boolean haveSameCategory(int a, int b): Returns true if items a and b belong to the same category, false otherwise. If either a or b is invalid (< 0 or >= n), it returns false.

Your goal: Find the total number of unique categories among all items.

Example: If items [0,1,2,3,4] have categories [A,A,B,C,B], then there are 3 unique categories.

Input & Output

example_1.py — Basic Case

$ Input: n = 5 Categories: [A, A, B, C, B] haveSameCategory(0,1) = true haveSameCategory(0,2) = false haveSameCategory(2,4) = true ...

› Output: 3

💡 Note: There are 3 unique categories: A (elements 0,1), B (elements 2,4), and C (element 3)

example_2.py — All Same Category

$ Input: n = 4 Categories: [X, X, X, X] haveSameCategory(i,j) = true for all i,j

› Output: 1

💡 Note: All elements belong to the same category X, so there's only 1 unique category

example_3.py — All Different Categories

$ Input: n = 3 Categories: [P, Q, R] haveSameCategory(i,j) = false for all i≠j

› Output: 3

💡 Note: Each element is in its own unique category, so there are 3 unique categories

Constraints

1 ≤ n ≤ 100
The haveSameCategory function is guaranteed to be consistent
Interactive constraint: You can only determine categories through the given function

Visualization

Tap to expand

Understanding the Visualization

Initialize

Start with each person in their own group

Ask Questions

For each pair, ask if they're friends (same category)

Merge Groups

When friends are found, merge their social circles

Count Groups

Final number of separate friend groups

Key Takeaway

🎯 Key Insight: Union-Find efficiently tracks which elements belong together, automatically counting distinct groups as we discover relationships

Asked in

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

The optimal approach uses Union-Find (Disjoint Set Union) to efficiently track connected components. Each component represents a unique category. We check all pairs of elements and union them if they belong to the same category. The final count of components gives us the number of unique categories in O(n² × α(n)) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Group Building)	O(n²)	O(n)	Build groups by comparing each element with all others
Union-Find (Optimal)	O(n² × α(n))	O(n)	Use Union-Find data structure to efficiently track connected components

Brute Force (Group Building) — Algorithm Steps

Initialize a visited array to track processed elements
For each unvisited element, start a new group
Check this element against all other unvisited elements
Add matching elements to the current group and mark as visited
Count the total number of groups formed

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with element 0

Begin new group, check against all others

Group formation

Add matching elements to current group

Next unvisited

Move to next unvisited element, start new group

Code -

solution.c — C

int numberOfUniqueCategories(int n, CategoryHandler* categoryHandler) {
    bool* visited = (bool*)calloc(n, sizeof(bool));
    int uniqueCategories = 0;
    
    for (int i = 0; i < n; i++) {
        if (!visited[i]) {
            // Start a new group with element i
            uniqueCategories++;
            visited[i] = true;
            
            // Find all elements in the same category as i
            for (int j = i + 1; j < n; j++) {
                if (!visited[j] && haveSameCategory(categoryHandler, i, j)) {
                    visited[j] = true;
                }
            }
        }
    }
    
    free(visited);
    return uniqueCategories;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n elements, we might check up to n other elements using haveSameCategory()

⚠ Quadratic Growth

Space Complexity

O(n)

Need visited array to track processed elements and space for group storage

⚡ Linearithmic Space

76.2K Views

Medium Frequency

~25 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 (Group Building) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler