Maximum Tastiness of Candy Basket - Practice Coding Problems

Maximum Tastiness of Candy Basket - Problem

Imagine you're a candy connoisseur tasked with creating the most balanced candy basket possible! 🍭

You're given an array price where price[i] represents the price of the i-th candy. You need to select exactly k distinct candies to create a basket.

The tastiness of your basket is defined as the smallest absolute difference between the prices of any two candies in the basket. In other words, you want to avoid having candies that are too similar in price - the more spread out the prices, the more "tasteful" your selection!

Goal: Return the maximum possible tastiness you can achieve.

Example: If prices are [1, 3, 1] and k = 2, you could pick candies with prices [1, 3] giving tastiness = |3-1| = 2. This is optimal!

Input & Output

example_1.py — Basic Case

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

› Output: 2

💡 Note: We can select candies with prices [1,3]. The tastiness is min(|1-3|) = 2, which is the maximum possible.

example_2.py — Multiple Options

$ Input: price = [4,3,5,10], k = 2

› Output: 5

💡 Note: We can select candies with prices [3,10] or [4,10] or [5,10]. The maximum tastiness is min(|3-10|, |4-10|, |5-10|) = min(7,6,5) = 5 from [5,10].

example_3.py — Larger Basket

$ Input: price = [1,2,5,8,13,21], k = 3

› Output: 8

💡 Note: Optimal selection is [1,13,21] giving tastiness = min(|13-1|, |21-1|, |21-13|) = min(12,20,8) = 8.

Constraints

2 ≤ k ≤ price.length ≤ 10⁵
1 ≤ price[i] ≤ 10⁹
Important: We need to select exactly k distinct candies

Visualization

Tap to expand

Understanding the Visualization

Sort the Prices

Arrange candy prices in ascending order: [1,3,7,9]

Binary Search Setup

Search for maximum minimum difference in range [0, max-min]

Greedy Selection

For each candidate difference, greedily select k candies with that spacing

Find Maximum

The largest feasible minimum difference is our answer

Key Takeaway

🎯 Key Insight: Instead of trying all combinations, we binary search on the answer (minimum difference) and greedily check feasibility - this reduces complexity from exponential to O(n log n log(range))!

Asked in

G Google 45 a Amazon 38 f Meta 25 ⊞ Microsoft 22

The optimal approach uses binary search on the answer combined with a greedy selection strategy. After sorting the prices, we binary search on the possible minimum difference values and use a greedy algorithm to check if we can select k candies with at least that minimum difference. The key insight is that if we can achieve a certain minimum difference, we should greedily pick candies as far apart as possible.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(C(n,k) * k²)	O(k)	Generate all possible combinations of k candies and find maximum tastiness
Binary Search on Answer + Greedy	O(n log n log(max-min))	O(1)	Binary search on the minimum difference, greedily check if k candies can be selected

Brute Force (Try All Combinations) — Algorithm Steps

Generate all combinations of k candies from the price array
For each combination, calculate all pairwise differences
Find the minimum difference in each combination (tastiness)
Return the maximum tastiness across all combinations

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Create all possible ways to choose k candies from n candies

Calculate Tastiness

For each combination, find the minimum price difference

Track Maximum

Keep track of the highest tastiness found

Code -

solution.c — C

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

int maxTastiness = 0;

void generateCombinations(int* price, int n, int k, int start, int count, int* selected) {
    if (count == k) {
        int selectedPrices[1000];
        int selectedCount = 0;
        
        for (int i = 0; i < n; i++) {
            if (selected[i]) {
                selectedPrices[selectedCount++] = price[i];
            }
        }
        
        int minDiff = INT_MAX;
        for (int i = 0; i < selectedCount; i++) {
            for (int j = i + 1; j < selectedCount; j++) {
                int diff = abs(selectedPrices[i] - selectedPrices[j]);
                if (diff < minDiff) {
                    minDiff = diff;
                }
            }
        }
        
        if (minDiff > maxTastiness) {
            maxTastiness = minDiff;
        }
        return;
    }
    
    for (int i = start; i < n; i++) {
        selected[i] = 1;
        generateCombinations(price, n, k, i + 1, count + 1, selected);
        selected[i] = 0;
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int price[1000];
    int n = 0;
    char* token = strtok(line, " ");
    while (token != NULL) {
        price[n++] = atoi(token);
        token = strtok(NULL, " ");
    }
    
    int k;
    scanf("%d", &k);
    
    int selected[1000] = {0};
    generateCombinations(price, n, k, 0, 0, selected);
    
    printf("%d\n", maxTastiness);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(C(n,k) * k²)

C(n,k) combinations, each requiring O(k²) time to find minimum difference

✓ Linear Growth

Space Complexity

O(k)

Space to store current combination

✓ Linear Space

48.0K Views

Medium-High Frequency

~25 min Avg. Time

1.4K 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 (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler