Distribute Candies - Practice Coding Problems

Distribute Candies - Problem

Candy Distribution Problem

Alice has collected n candies of various types, where each candy is represented by candyType[i]. However, her doctor has advised her to eat only half of her candies (n/2) to maintain her health.

Alice wants to maximize her candy-eating experience by consuming the maximum number of different candy types while following her doctor's advice. Given an integer array candyType of length n (where n is always even), return the maximum number of different types of candies Alice can eat if she only eats n/2 of them.

Example: If Alice has 6 candies of types [1,1,2,2,3,3], she can eat 3 candies. To maximize variety, she should pick one candy of each type (1, 2, and 3), giving her 3 different types.

Input & Output

example_1.py — Basic Case

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

› Output: 3

💡 Note: Alice has 6 candies with 3 different types. She can eat 6/2 = 3 candies. Since there are exactly 3 unique types, she can eat one of each type to maximize variety.

example_2.py — Limited by Candy Count

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

› Output: 2

💡 Note: Alice has 4 candies with 3 different types. She can only eat 4/2 = 2 candies. Even though there are 3 unique types, she's limited to eating only 2 different types.

example_3.py — All Same Type

$ Input: [6,6,6,6]

› Output: 1

💡 Note: Alice has 4 candies but they're all the same type. She can eat 4/2 = 2 candies, but since there's only 1 unique type, she can only experience 1 different candy type.

Constraints

n == candyType.length
2 ≤ n ≤ 10⁴
n is even
-10⁵ ≤ candyType[i] ≤ 10⁵

Visualization

Tap to expand

Understanding the Visualization

Survey the Options

Count how many different types of candies are available

Check Your Limit

Determine how many candies you're allowed to eat (n/2)

Maximize Variety

Take the minimum of available types and your eating limit

Key Takeaway

🎯 Key Insight: The answer is always min(unique_candy_types, n/2). Alice maximizes variety by choosing one candy from each unique type, limited by either available variety or eating constraint.

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 f Meta 6

The optimal solution uses a hash set to count unique candy types in O(n) time. The key insight is that Alice can eat min(unique_types, n/2) different candy types - she's either limited by the variety available or by the doctor's eating restriction.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Set (Optimal)	O(n)	O(min(n, k))	Use a hash set to count unique candy types in a single pass
Brute Force (Nested Loops)	O(n²)	O(1)	Count unique candy types by comparing each candy with all others

One-Pass Hash Set (Optimal) — Algorithm Steps

Create an empty hash set to store unique candy types
Iterate through the candy array once
Add each candy type to the hash set (duplicates automatically ignored)
Return minimum of set size and n/2

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Set

Start with empty hash set

Process Candies

Add each candy type to set (duplicates ignored)

Calculate Result

Return min(set_size, n/2)

Code -

solution.c — C

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

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

int distributeCandies(int* candyType, int candyTypeSize) {
    // Sort array to group same types together
    qsort(candyType, candyTypeSize, sizeof(int), compare);
    
    // Count unique types
    int uniqueCount = 1;
    for (int i = 1; i < candyTypeSize; i++) {
        if (candyType[i] != candyType[i-1]) {
            uniqueCount++;
        }
    }
    
    // Alice can eat at most n/2 candies
    int maxAllowed = candyTypeSize / 2;
    
    // Return minimum of unique types and allowed amount
    return (uniqueCount < maxAllowed) ? uniqueCount : maxAllowed;
}

int main() {
    int n;
    scanf("%d", &n);
    int* candyType = (int*)malloc(n * sizeof(int));
    
    for (int i = 0; i < n; i++) {
        scanf("%d", &candyType[i]);
    }
    
    printf("%d\n", distributeCandies(candyType, n));
    free(candyType);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array of n candies

✓ Linear Growth

Space Complexity

O(min(n, k))

Hash set stores at most k unique candy types, bounded by n

⚡ Linearithmic Space

78.3K Views

Medium Frequency

~15 min Avg. Time

2.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

One-Pass Hash Set (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler