Buy Two Chocolates - Practice Coding Problems

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

Understanding the Visualization

Input

Array of chocolate prices and available money

Find Minimum Pair

Identify the two cheapest chocolates

Calculate Leftover

Return money minus cost, or original money if unaffordable

Key Takeaway

🎯 Key Insight: We only need to find the two minimum prices, not sort the entire array

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

Approach	Time	Space	Notes
✓ One Pass - Find Two Minimums	O(n)	O(1)	Find the two smallest values in a single pass without sorting
Sort Then Pick Two Cheapest	O(n log n)	O(1)	Sort the prices array and pick the two smallest values
Brute Force - Check All Pairs	O(n²)	O(1)	Try every possible pair of chocolates to find the minimum cost combination

One Pass - Find Two Minimums — Algorithm Steps

Initialize first_min and second_min to infinity
Traverse array once, updating the two minimums
Check if first_min + second_min <= money
Return money - sum if affordable, else return money

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Minimums

Set first_min and second_min to infinity

Update on Each Element

Maintain two smallest values as we scan

Calculate Result

Use the two minimums to compute leftover

Code -

solution.c — C

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

int solution(int* prices, int pricesSize, int money) {
    // Find two minimum values in one pass
    int firstMin = INT_MAX;
    int secondMin = INT_MAX;
    
    for (int i = 0; i < pricesSize; i++) {
        if (prices[i] < firstMin) {
            secondMin = firstMin;
            firstMin = prices[i];
        } else if (prices[i] < secondMin) {
            secondMin = prices[i];
        }
    }
    
    int minCost = firstMin + secondMin;
    return minCost <= money ? 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)

Single pass through array to find two minimum values

✓ Linear Growth

Space Complexity

O(1)

Only using two variables to track minimum values

✓ 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

One Pass - Find Two Minimums — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler