Buy Two Chocolates

Buy Two Chocolates - Problem

You are given an integer array prices representing the prices of various chocolates in a store. You are also given a single integer money, which represents your initial amount of money.

You must buy exactly two chocolates in such a way that you still have some non-negative leftover money. You would like to minimize the sum of the prices of the two chocolates you buy.

Return the amount of money you will have leftover after buying the two chocolates. If there is no way for you to buy two chocolates without ending up in debt, return money. Note that the leftover must be non-negative.

Input & Output

Example 1 — Basic Case

$ Input: prices = [1,2,3], money = 4

› Output: 1

💡 Note: The two cheapest chocolates cost 1 + 2 = 3, which is affordable. Leftover money: 4 - 3 = 1

Example 2 — Cannot Afford Any Pair

$ Input: prices = [3,2,3], money = 3

› Output: 3

💡 Note: The cheapest pair costs 2 + 3 = 5, which exceeds our budget of 3. Return original money: 3

Example 3 — Exact Budget Match

$ Input: prices = [1,3,2], money = 3

› Output: 0

💡 Note: Cheapest pair costs 1 + 2 = 3, exactly our budget. Leftover: 3 - 3 = 0

Constraints

2 ≤ prices.length ≤ 50
1 ≤ prices[i] ≤ 100
1 ≤ money ≤ 100

Visualization

Tap to expand

Asked in

LC LeetCode 15 M Meta 8

The key insight is that we need to find the two cheapest chocolates to minimize cost. The optimal approach finds the two minimum values in O(n) time without sorting. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force - Check All Pairs

⏱️ Time: O(n²) Space: O(1)

Check all possible pairs of chocolates, calculate their total cost, and find the minimum cost that doesn't exceed our budget. If we can afford the minimum pair, return the leftover money.

One Pass - Find Two Minimums

⏱️ Time: O(n) Space: O(1)

Traverse the array once to find the smallest and second smallest values. This avoids the overhead of sorting when we only need two minimum elements.

Sort Then Pick Two Cheapest

⏱️ Time: O(n log n) Space: O(1)

Sort the prices in ascending order, then check if we can afford the two cheapest chocolates. This guarantees we get the minimum possible cost if any combination is affordable.

Brute Force - Check All Pairs — Algorithm Steps

Iterate through all pairs (i, j) where i < j
For each pair, calculate cost = prices[i] + prices[j]
Track minimum cost among affordable pairs
Return money - minCost if affordable, otherwise return original money

Visualization

Tap to expand

Step-by-Step Walkthrough

Try All Pairs

Check every combination of two chocolates

Find Minimum

Track the cheapest affordable pair

Calculate Leftover

Return money minus minimum cost

Code -

solution.c — C

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

int solution(int* prices, int pricesSize, int money) {
    int minCost = INT_MAX;
    
    // Try all pairs
    for (int i = 0; i < pricesSize; i++) {
        for (int j = i + 1; j < pricesSize; j++) {
            int cost = prices[i] + prices[j];
            if (cost <= money && cost < minCost) {
                minCost = cost;
            }
        }
    }
    
    // Return leftover money or original money if can't afford
    return minCost != INT_MAX ? money - minCost : money;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int prices[1000];
    int pricesSize = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (token[0] >= '0' && token[0] <= '9') {
            prices[pricesSize++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int money;
    scanf("%d", &money);
    
    int result = solution(prices, pricesSize, money);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops check all n×(n-1)/2 pairs of chocolates

✓ Linear Growth

Space Complexity

O(1)

Only using variables to track minimum cost

✓ Linear Space

12.5K Views

Medium Frequency

~15 min Avg. Time

432 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 - Check All Pairs — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler