Number of Unique Flavors After Sharing K Candies

Number of Unique Flavors After Sharing K Candies - Problem

You're a candy enthusiast with a collection of various flavored candies! 🍭 Your mom wants you to share k consecutive candies with your little sister, but being the flavor connoisseur you are, you want to maximize the variety of flavors you get to keep.

Given an array candies where candies[i] represents the flavor of the i-th candy, you need to determine which k consecutive candies to give away so that you retain the maximum number of unique flavors.

Goal: Find the optimal subarray of length k to remove that leaves you with the most diverse flavor collection.

Example: If you have candies [1,2,1,3,4,3,2] and need to share k=3 candies, you could give away [1,3,4] (indices 2-4) and keep flavors [1,2,3,2] which has 3 unique flavors!

Input & Output

example_1.py — Basic Case

$ Input: candies = [1,2,1,3,4,3,2], k = 3

› Output: 3

💡 Note: Remove subarray [1,3,4] (indices 2-4) to keep [1,2,3,2] which has 3 unique flavors (1,2,3). This is optimal.

example_2.py — All Same Flavors

$ Input: candies = [1,1,1,1,1], k = 2

› Output: 1

💡 Note: All candies have the same flavor, so removing any k=2 consecutive candies leaves us with only 1 unique flavor.

example_3.py — Edge Case

$ Input: candies = [1,2,3], k = 1

› Output: 2

💡 Note: Remove any single candy to keep 2 unique flavors. For example, remove [2] to keep [1,3] with 2 unique flavors.

Visualization

Tap to expand

Understanding the Visualization

Survey Collection

Count all flavor types in your candy collection

Try Each Section

Consider each possible consecutive group of k candies to give away

Calculate Remaining

For each section, determine how many unique flavors you'd keep

Choose Optimal

Select the section that leaves you with maximum flavor variety

Key Takeaway

🎯 Key Insight: Use sliding window with frequency counting to efficiently try all possible consecutive removals without recalculating everything each time.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array with constant time operations for each element

✓ Linear Growth

Space Complexity

O(n)

Hash maps store at most n unique flavors

⚡ Linearithmic Space

Constraints

1 ≤ candies.length ≤ 10⁵
1 ≤ candies[i] ≤ 10⁵
1 ≤ k ≤ candies.length
All array values are positive integers

Asked in

G Google 42 a Amazon 35 f Meta 28 ⊞ Microsoft 21

The optimal solution uses a sliding window approach with frequency maps. We maintain counts of all flavors and the current window of k candies to remove. By sliding the window and updating frequency counts incrementally, we can find the maximum unique flavors remaining in O(n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Sliding Window with Hash Maps (Optimal)	O(n)	O(n)	Use sliding window technique with frequency maps to efficiently track unique flavors
Brute Force (Try All Subarrays)	O(n²)	O(n)	Check every possible k-length subarray to remove and count remaining unique flavors

Sliding Window with Hash Maps (Optimal) — Algorithm Steps

Count frequency of all flavors in the original array
Initialize sliding window with first k elements
For each window position, calculate remaining unique flavors using frequency difference
Slide window right: add new element, remove leftmost element, update counts
Track maximum unique flavors throughout the process

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Counts

Count all flavors and set up initial window

Calculate Remaining

For each flavor, check if total_count > window_count

Slide Window

Remove left element, add right element, update counts

Track Maximum

Keep track of the best result found so far

Code -

solution.c — C

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

int maxUniqueFlavors(int* candies, int n, int k) {
    if (k >= n) return 0;
    
    int totalCount[1001] = {0}; // Assuming flavors <= 1000
    int windowCount[1001] = {0};
    
    // Count all flavors in original array
    for (int i = 0; i < n; i++) {
        totalCount[candies[i]]++;
    }
    
    // Count flavors in initial window [0, k)
    for (int i = 0; i < k; i++) {
        windowCount[candies[i]]++;
    }
    
    int maxUnique = 0;
    
    // Try each possible window position
    for (int start = 0; start <= n - k; start++) {
        // Calculate remaining unique flavors
        int remainingUnique = 0;
        for (int flavor = 0; flavor <= 1000; flavor++) {
            if (totalCount[flavor] > windowCount[flavor]) {
                remainingUnique++;
            }
        }
        
        if (remainingUnique > maxUnique) {
            maxUnique = remainingUnique;
        }
        
        // Slide window: remove leftmost, add new rightmost
        if (start < n - k) {
            // Remove leftmost element from window
            windowCount[candies[start]]--;
            // Add new rightmost element to window
            windowCount[candies[start + k]]++;
        }
    }
    
    return maxUnique;
}

int main() {
    // Input parsing implementation
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array with constant time operations for each element

✓ Linear Growth

Space Complexity

O(n)

Hash maps store at most n unique flavors

⚡ Linearithmic Space

Constraints

1 ≤ candies.length ≤ 10⁵
1 ≤ candies[i] ≤ 10⁵
1 ≤ k ≤ candies.length
All array values are positive integers

42.6K Views

High Frequency

~18 min Avg. Time

1.3K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Sliding Window with Hash Maps (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler