Find the Number of Distinct Colors Among the Balls

Find the Number of Distinct Colors Among the Balls - Problem

Imagine you have a collection of numbered balls and a magical palette of colors! 🎨

You start with limit + 1 balls, each labeled with a unique number from 0 to limit. Initially, all balls are colorless - waiting to be painted!

You receive a series of painting instructions in the form of queries [x, y], where:

x is the ball number to paint
y is the color to use

After each painting instruction, you need to count how many distinct colors are currently visible among all the balls. Remember: unpainted balls don't count as having any color!

Goal: Return an array where each element represents the number of distinct colors after processing each query.

Example: If you have balls [0,1,2] and queries [[1,3], [0,3], [2,5]], after the first query you have 1 distinct color (3), after the second you still have 1 distinct color (3), and after the third you have 2 distinct colors (3 and 5).

Input & Output

example_1.py — Basic Color Tracking

$ Input: limit = 3, queries = [[1,4],[0,1],[1,3],[3,4]]

› Output: [1,2,2,2]

💡 Note: Ball 1→color 4 (1 distinct), Ball 0→color 1 (2 distinct), Ball 1→color 3 (still 2 distinct: colors 1,3), Ball 3→color 4 (still 2 distinct: colors 1,3 since color 4 reappeared)

example_2.py — Color Replacement

$ Input: limit = 2, queries = [[0,1],[1,2],[0,2]]

› Output: [1,2,1]

💡 Note: Ball 0→color 1 (1 distinct), Ball 1→color 2 (2 distinct), Ball 0→color 2 (1 distinct since both balls now have color 2)

example_3.py — Single Ball Multiple Colors

$ Input: limit = 1, queries = [[0,5],[0,8],[0,5]]

› Output: [1,1,1]

💡 Note: Only one ball exists, so regardless of which color we paint it, there's always exactly 1 distinct color in the collection

Constraints

1 ≤ limit ≤ 10⁵
1 ≤ queries.length ≤ 10⁵
queries[i].length == 2
0 ≤ queries[i][0] ≤ limit
1 ≤ queries[i][1] ≤ 10⁹
All ball indices are valid and colors are positive integers

Visualization

Tap to expand

Understanding the Visualization

Gallery Setup

Start with numbered frames (balls), all empty initially

Visitor Request

A visitor requests painting frame X with color Y

Smart Update

Update your logbook: track color usage efficiently

Instant Answer

Provide the current distinct color count immediately

Key Takeaway

🎯 Key Insight: Instead of recounting everything after each change, maintain a smart tracking system that updates incrementally. This transforms an O(n×limit) problem into an O(n) solution!

Asked in

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

The optimal solution uses a hash map to track color counts and maintains a running counter of distinct colors. Instead of rescanning all balls after each query (O(n×limit)), we update our tracking structures in O(1) time per query, achieving overall O(n) time complexity. The key insight is to increment the distinct count only when a color appears for the first time, and decrement it only when a color completely disappears.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Map Color Tracking (Optimal)	O(n)	O(limit + colors)	Use a hash map to track color counts and maintain distinct color count efficiently
Brute Force (Count Colors After Each Query)	O(n × limit)	O(limit)	After each query, scan all balls and count distinct colors

Hash Map Color Tracking (Optimal) — Algorithm Steps

Initialize a hash map to count occurrences of each color
Keep a counter for the total number of distinct colors
For each query, check if the ball was previously colored
Update color counts and distinct color counter accordingly
Add current distinct count to result

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set up ball array, color count map, and distinct counter

Process Query

Handle old color removal and new color addition

Update Counters

Adjust distinct color count based on changes

Record Result

Add current distinct count to result

Code -

solution.c — C

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

#define MAX_COLORS 100001

int* distinctColors(int limit, int** queries, int queriesSize, int* returnSize) {
    int* balls = (int*)malloc((limit + 1) * sizeof(int));
    int* colorCount = (int*)calloc(MAX_COLORS, sizeof(int));
    int* result = (int*)malloc(queriesSize * sizeof(int));
    *returnSize = queriesSize;
    
    // Initialize balls as uncolored
    for (int i = 0; i <= limit; i++) {
        balls[i] = -1;
    }
    
    int distinctColors = 0;
    
    for (int i = 0; i < queriesSize; i++) {
        int x = queries[i][0];
        int y = queries[i][1];
        int oldColor = balls[x];
        
        // Remove old color if exists
        if (oldColor != -1) {
            colorCount[oldColor]--;
            if (colorCount[oldColor] == 0) {
                distinctColors--;
            }
        }
        
        // Add new color
        balls[x] = y;
        if (colorCount[y] == 0) {
            distinctColors++;
        }
        colorCount[y]++;
        
        result[i] = distinctColors;
    }
    
    free(balls);
    free(colorCount);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each query is processed in constant time using hash map operations

✓ Linear Growth

Space Complexity

O(limit + colors)

Space for ball colors array plus hash map storing at most 'colors' distinct entries

✓ Linear Space

52.3K Views

Medium Frequency

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

Hash Map Color Tracking (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler