Lemonade Change

Lemonade Change - Problem

Array Greedy Easy

At a lemonade stand, each lemonade costs $5. Customers are standing in a queue to buy from you and order one at a time (in the order specified by bills). Each customer will only buy one lemonade and pay with either a $5, $10, or $20 bill.

You must provide the correct change to each customer so that the net transaction is that the customer pays $5. Note that you do not have any change in hand at first.

Given an integer array bills where bills[i] is the bill the ith customer pays, return true if you can provide every customer with the correct change, or false otherwise.

Input & Output

Example 1 — Mixed Bills

$ Input: bills = [5,5,5,10,20]

› Output: true

💡 Note: Customer 1-3: pay $5, no change needed. Customer 4: pays $10, give $5 change. Customer 5: pays $20, give $10+$5 change.

Example 2 — Cannot Make Change

$ Input: bills = [5,5,10,10,20]

› Output: false

💡 Note: For the last customer paying $20, we need $15 change but only have $10+$10+$5 available. We cannot make exactly $15.

Example 3 — All Same Bills

$ Input: bills = [5,5,5,5]

› Output: true

💡 Note: All customers pay exact amount ($5), so no change is needed.

Constraints

1 ≤ bills.length ≤ 10⁵
bills[i] is either 5, 10, or 20

Visualization

Tap to expand

Asked in

G Google 12 a Amazon 8 M Microsoft 6 f Facebook 4

The key insight is that a greedy approach works optimally for this currency system. The best approach is to track counts of $5 and $10 bills, and always use the largest denominations first when making change. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force Simulation

⏱️ Time: O(n × 2^k) Space: O(k)

For each customer, try all possible ways to make change using available bills. This involves checking every combination of bills that sum to the required change amount.

Greedy Strategy

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

Keep track of count of $5 and $10 bills. When making change, always use the largest bills first - this greedy approach is optimal for this currency system.

Brute Force Simulation — Algorithm Steps

For each customer, determine required change
Try all combinations of available bills
If any combination works, proceed; otherwise return false

Visualization

Tap to expand

Step-by-Step Walkthrough

Customer Arrives

Customer pays with $10, needs $5 change

Try Combinations

Check all ways to make $5 from available bills

Make Change

Use first valid combination found

Code -

solution.c — C

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

bool canMakeChange(int amount, int fives, int tens) {
    if (amount == 0) return true;
    if (amount < 0) return false;
    
    if (tens > 0 && canMakeChange(amount - 10, fives, tens - 1)) {
        return true;
    }
    if (fives > 0 && canMakeChange(amount - 5, fives - 1, tens)) {
        return true;
    }
    
    return false;
}

bool solution(int* bills, int billsSize) {
    int fives = 0, tens = 0, twenties = 0;
    
    for (int i = 0; i < billsSize; i++) {
        int bill = bills[i];
        int changeNeeded = bill - 5;
        
        if (changeNeeded > 0) {
            if (!canMakeChange(changeNeeded, fives, tens)) {
                return false;
            }
            // Actually make the change
            int remaining = changeNeeded;
            while (remaining >= 10 && tens > 0) {
                tens--;
                remaining -= 10;
            }
            while (remaining >= 5 && fives > 0) {
                fives--;
                remaining -= 5;
            }
        }
        
        if (bill == 5) fives++;
        else if (bill == 10) tens++;
        else twenties++;
    }
    
    return true;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int bills[1000];
    int count = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != '\n') {
            bills[count++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    printf(solution(bills, count) ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × 2^k)

For each customer (n), we try all subsets (2^k) of available bills to make change

✓ Linear Growth

Space Complexity

O(k)

Store counts of available bills where k is number of distinct bill types

✓ Linear Space

187.4K Views

Medium Frequency

~15 min Avg. Time

2.8K 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 Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler