Lemonade Change - Practice Coding Problems

Lemonade Change - Problem

Array Greedy Easy

You're running a bustling lemonade stand! 🍋 Each cup of delicious lemonade costs exactly $5, and customers are lining up to buy from you. Here's the challenge: customers pay with $5, $10, or $20 bills, and you need to give them the correct change so they effectively pay exactly $5.

The tricky part? You start with no money in your cash register! This means you can only make change using the bills you've received from previous customers.

Your task: Given an array bills where each element represents the bill amount a customer pays (in order), determine if you can successfully provide correct change to every single customer. Return true if possible, false otherwise.

Example: If a customer pays with a $10 bill, you need to give them $5 change. If a customer pays with a $20 bill, you need to give them $15 change (preferably one $10 and one $5).

Input & Output

example_1.py — Basic Success Case

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

› Output: true

💡 Note: Customer 1-3 pay with $5 (no change needed). Customer 4 pays $10, we give $5 change. Customer 5 pays $20, we give $15 change ($10 + $5). We can handle all customers successfully.

example_2.py — Early Failure

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

› Output: false

💡 Note: After the first 4 customers, we have zero $5 bills and two $10 bills. When customer 5 pays $20, we need $15 change but can't make it with two $10 bills. We need at least one $5 bill.

example_3.py — Edge Case

$ Input: [5,5,5,5,20,20,20,20,20]

› Output: false

💡 Note: We start with four $5 bills. First $20 customer takes 3 of them (leaving 1). Second $20 customer would need 3 more $5 bills but we only have 1 remaining.

Constraints

1 ≤ bills.length ≤ 10⁵
bills[i] is either 5, 10, or 20
All customers must be served in the order they appear in the array

Visualization

Tap to expand

Understanding the Visualization

Collect $5 bills

These are pure profit - no change needed, but crucial for future transactions

Handle $10 bills

Easy trade: give one $5 as change, gain one $10 (which helps with $20s later)

Strategic $20 handling

Always prefer giving $10+$5 change over three $5s to preserve smaller denominations

Early termination

Return false immediately when you can't make change - no point continuing

Key Takeaway

🎯 Key Insight: This is a perfect greedy problem! Always prioritize preserving smaller denominations ($5 bills) since they're needed for all change-making scenarios, while larger bills ($10, $20) have limited utility.

Asked in

G Google 12 a Amazon 18 f Meta 8 ⊞ Microsoft 6 Apple 5

The optimal approach uses a greedy strategy with simple bill counting. Track only $5 and $10 bills (no need to store $20s). For $20 payments, prioritize giving $10 + $5 change over three $5 bills to preserve flexibility. This runs in O(n) time and O(1) space.

Common Approaches

Approach	Time	Space	Notes
✓ Simulation with Bill Tracking	O(n)	O(1)	Track each bill denomination and simulate the change-making process

Simulation with Bill Tracking — Algorithm Steps

Initialize counters for $5 and $10 bills (we don't need to store $20s)
For each customer's bill, determine the required change
If $5 bill: no change needed, increment $5 counter
If $10 bill: need $5 change, check if we have a $5 bill
If $20 bill: need $15 change, prefer $10+$5, otherwise use three $5s
Return false immediately if we can't make change, true if we process all customers

Visualization

Tap to expand

Step-by-Step Walkthrough

Customer pays $5

No change needed, add $5 to register

Customer pays $10

Give $5 change, add $10 to register

Customer pays $20

Give $15 change (prefer $10+$5 over three $5s)

Check availability

Return false if we can't make proper change

Code -

solution.c — C

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

bool lemonadeChange(int* bills, int billsSize) {
    int fiveCount = 0;
    int tenCount = 0;
    
    for (int i = 0; i < billsSize; i++) {
        int bill = bills[i];
        if (bill == 5) {
            fiveCount++;
        } else if (bill == 10) {
            if (fiveCount > 0) {
                fiveCount--;
                tenCount++;
            } else {
                return false;
            }
        } else if (bill == 20) {
            // Prefer giving one $10 and one $5 as change
            if (tenCount > 0 && fiveCount > 0) {
                tenCount--;
                fiveCount--;
            } else if (fiveCount >= 3) {
                fiveCount -= 3;
            } else {
                return false;
            }
        }
    }
    
    return true;
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    int bills[1000];
    int count = 0;
    char* token = strtok(input, "[],\n ");
    while (token != NULL) {
        bills[count++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    printf("%s\n", lemonadeChange(bills, count) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We process each customer exactly once in a single pass through the array

✓ Linear Growth

Space Complexity

O(1)

We only need two variables to track $5 and $10 bill counts

✓ Linear Space

42.3K Views

Medium Frequency

~12 min Avg. Time

1.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

Simulation with Bill Tracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler