Minimum Cost of Buying Candies With Discount

Minimum Cost of Buying Candies With Discount - Problem

🍬 Welcome to the Sweet Candy Shop! This shop has an amazing deal that will make any candy lover excited.

The Deal: For every two candies you buy, you get a third candy absolutely free! But there's a catch - the free candy must cost less than or equal to the cheaper of the two candies you purchased.

Your Mission: Given an array cost where cost[i] represents the price of the i-th candy, find the minimum total cost to buy all candies using this discount optimally.

Example Strategy: If candies cost [1, 2, 3, 4] and you buy candies costing 2 and 3, you can take the candy costing 1 for free (since 1 ≤ min(2,3) = 2), but not the candy costing 4.

Goal: Return the minimum cost to purchase all candies by strategically using the buy-2-get-1-free discount.

Input & Output

example_1.py — Basic case with perfect groups

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

› Output: 5

💡 Note: Buy candies with costs 2 and 3, get candy with cost 1 free. Total cost = 2 + 3 = 5.

example_2.py — Mixed grouping required

$ Input: cost = [6, 5, 7, 9, 2, 2]

› Output: 23

💡 Note: Sort: [9,7,6,5,2,2]. Group 1: buy 9+7, get 6 free (cost=16). Group 2: buy 5+2, get 2 free (cost=7). Total = 16 + 7 = 23.

example_3.py — Edge case with remainder

$ Input: cost = [5, 5]

› Output: 10

💡 Note: Only 2 candies, cannot form a group of 3. Must buy both candies at full price. Total = 5 + 5 = 10.

Constraints

1 ≤ cost.length ≤ 1000
1 ≤ cost[i] ≤ 100
All candy costs are positive integers

Visualization

Tap to expand

Understanding the Visualization

Survey the Store

Look at all candy prices and arrange them from most to least expensive

Strategic Grouping

Group candies in sets of 3, always putting the most expensive ones first

Apply the Deal

For each group of 3, buy the 2 most expensive and get the cheapest one free

Final Purchase

Buy any remaining 1-2 candies at full price

Key Takeaway

🎯 Key Insight: By sorting candies in descending order and using a greedy approach, we maximize our savings by always getting the most expensive possible candies for free while respecting the discount rules.

Asked in

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

The optimal solution uses a greedy approach: sort candies by price in descending order, then process in groups of 3 where we buy the 2 most expensive and get the cheapest free. This maximizes savings by always getting the most valuable candies for free. Time complexity: O(n log n) for sorting.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Approach (Optimal)	O(n log n)	O(1)	Sort candies in descending order and greedily form optimal groups
Brute Force (Try All Combinations)	O(3^n)	O(n)	Try every possible way to group candies into buy-2-get-1-free sets

Greedy Approach (Optimal) — Algorithm Steps

Sort candies in descending order by price
Process candies in groups of 3
For each group: buy the 2 most expensive, get the cheapest free
Add remaining 1-2 candies to total cost if any

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Descending

Arrange candies from most to least expensive

Group by 3

Take groups of 3 candies each

Apply Discount

Buy 2 most expensive, get cheapest free

Handle Remainder

Buy any remaining 1-2 candies normally

Code -

solution.c — C

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

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

int minimumCost(int *cost, int n) {
    // Sort in descending order
    qsort(cost, n, sizeof(int), compare);
    
    int totalCost = 0;
    int i = 0;
    
    while (i < n) {
        if (i + 2 < n) {
            // Buy 2, get 1 free
            totalCost += cost[i] + cost[i + 1];
            i += 3;
        } else {
            // Buy remaining
            while (i < n) {
                totalCost += cost[i];
                i++;
            }
        }
    }
    
    return totalCost;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int cost[100];
    int n = 0;
    char *token = strtok(line, " \n");
    while (token != NULL) {
        cost[n++] = atoi(token);
        token = strtok(NULL, " \n");
    }
    
    printf("%d\n", minimumCost(cost, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting takes O(n log n), then single pass through array takes O(n)

⚡ Linearithmic

Space Complexity

O(1)

Only constant extra space for variables, sorting is in-place

✓ Linear Space

42.0K Views

Medium Frequency

~15 min Avg. Time

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

Greedy Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler