Lemonade Change in Python

The lemonade change problem is a classic greedy algorithm challenge. At a lemonade stand where each drink costs $5, customers pay with $5, $10, or $20 bills, and we must provide correct change. Starting with no money, we need to determine if we can serve all customers.

Problem Analysis

For each customer payment:

• $5 bill: No change needed, keep the bill
• $10 bill: Give back one $5 bill as change
• $20 bill: Give back $15 change (prefer one $10 + one $5, or three $5 bills)

Algorithm Approach

We use a greedy strategy, tracking counts of $5 and $10 bills (we don't need $20 bills for change). For $20 payments, we prioritize using larger denominations first to preserve smaller bills for future transactions.

def lemonade_change(bills):
    five_count = 0
    ten_count = 0
    
    for bill in bills:
        if bill == 5:
            five_count += 1
        elif bill == 10:
            # Need to give $5 change
            if five_count > 0:
                five_count -= 1
                ten_count += 1
            else:
                return False
        else:  # bill == 20
            # Need to give $15 change
            if ten_count > 0 and five_count > 0:
                # Use one $10 and one $5
                ten_count -= 1
                five_count -= 1
            elif five_count >= 3:
                # Use three $5 bills
                five_count -= 3
            else:
                return False
    
    return True

# Test with the example
bills = [5, 5, 5, 10, 20]
result = lemonade_change(bills)
print(f"Can provide change for {bills}: {result}")

Can provide change for [5, 5, 5, 10, 20]: True

Step-by-Step Walkthrough

Let's trace through the example [5, 5, 5, 10, 20]:

def lemonade_change_verbose(bills):
    five_count = 0
    ten_count = 0
    
    for i, bill in enumerate(bills):
        print(f"Customer {i+1}: pays ${bill}")
        
        if bill == 5:
            five_count += 1
            print(f"  No change needed. $5 bills: {five_count}")
        elif bill == 10:
            if five_count > 0:
                five_count -= 1
                ten_count += 1
                print(f"  Give $5 change. $5 bills: {five_count}, $10 bills: {ten_count}")
            else:
                print("  Cannot give change!")
                return False
        else:  # bill == 20
            if ten_count > 0 and five_count > 0:
                ten_count -= 1
                five_count -= 1
                print(f"  Give $10+$5 change. $5 bills: {five_count}, $10 bills: {ten_count}")
            elif five_count >= 3:
                five_count -= 3
                print(f"  Give three $5 bills change. $5 bills: {five_count}")
            else:
                print("  Cannot give change!")
                return False
    
    return True

bills = [5, 5, 5, 10, 20]
result = lemonade_change_verbose(bills)
print(f"\nFinal result: {result}")

Customer 1: pays $5
  No change needed. $5 bills: 1
Customer 2: pays $5
  No change needed. $5 bills: 2
Customer 3: pays $5
  No change needed. $5 bills: 3
Customer 4: pays $10
  Give $5 change. $5 bills: 2, $10 bills: 1
Customer 5: pays $20
  Give $10+$5 change. $5 bills: 1, $10 bills: 0

Final result: True

Testing Edge Cases

# Test various scenarios
test_cases = [
    [5, 5, 10],           # True - can give change
    [10, 10],             # False - no $5 bills for first customer
    [5, 5, 10, 10, 20],   # False - not enough change for $20
    [5, 5, 5, 5, 20]      # True - use three $5 bills for $20
]

for i, bills in enumerate(test_cases):
    result = lemonade_change(bills)
    print(f"Test {i+1}: {bills} ? {result}")

Test 1: [5, 5, 10] ? True
Test 2: [10, 10] ? False
Test 3: [5, 5, 10, 10, 20] ? False
Test 4: [5, 5, 5, 5, 20] ? True

Conclusion

The lemonade change problem demonstrates greedy algorithm principles. By prioritizing larger denominations for change and tracking bill counts, we can efficiently determine if all customers can be served. The key insight is always preferring $10 bills over multiple $5 bills when making change for $20.