Lemonade Change

class Solution {
public:
    bool handlePayments(vector<int>& payments) {
        int fives = 0;
        int tens = 0;

        for (int bill : payments) {
            switch(bill) {
                case 5:
                    fives++;
                    break;
                case 10:
                    if (fives == 0) return false;
                    fives--;
                    tens++;
                    break;
                case 20:
                    if (tens > 0 && fives > 0) {
                        tens--;
                        fives--;
                    } else if (fives >= 3) {
                        fives -= 3;
                    } else {
                        return false;
                    }
                    break;
            }
        }

        return true;
    }
};

The solution addresses the problem of determining whether you can provide the correct change for a series of transactions using bills of denominations 5, 10, and 20. The implementation is written in C++.

• Initialize two integer counters, fives and tens, to keep track of the number of $5 and $10 bills available.
• Iterate through each bill payment in the payments vector:
  • If the bill is $5, increase the count of fives.
  • If the bill is $10, check if there is at least one $5 bill available to give back as change. If so, decrement the fives count and increment the tens count. If a $5 bill is not available, return false.
  • For a $20 bill, the preferred change given back is one $10 bill and one $5 bill. If these are available, decrease both tens and fives by one each. If not, check if there are at least three $5 bills to give back as change. If neither condition is met, return false.
• If you can provide the necessary change for all the transactions, return true.

This solution efficiently manages the bills' inventory and ensures correct change is available for each transaction.

class Solution {

    public boolean validateLemonadeChange(int[] customerBills) {
        int countFive = 0;
        int countTen = 0;

        for (int bill : customerBills) {
            switch (bill) {
                case 5:
                    countFive++;
                    break;
                case 10:
                    if (countFive > 0) {
                        countFive--;
                        countTen++;
                    } else {
                        return false;
                    }
                    break;
                case 20:
                    if (countTen > 0 && countFive > 0) {
                        countFive--;
                        countTen--;
                    } else if (countFive >= 3) {
                        countFive -= 3;
                    } else {
                        return false;
                    }
                    break;
            }
        }
        return true;
    }
}

The provided Java code offers a solution to the Lemonade Change problem. The core objective is to determine if it's possible to provide every customer with the correct change using the bills received from previous customers.

• Initialize counters for $5 and $10 bills (countFive and countTen).
• Iterate through the array of customer bills.
• Use a switch-case structure to handle different bill types:
  • On receiving a $5 bill, increment countFive.
  • On receiving a $10 bill:
    • Check for at least one $5 bill for change. If available, decrement countFive and increment countTen. If not, return false.
  • On receiving a $20 bill:
    • Preferably, use one $10 and one $5 bill for change. Adjust counters appropriately. If not possible,
    • Alternatively, check for three $5 bills. If not sufficient, return false.
• If all customers can be provided change successfully, return true.

This method ensures efficient tracking and usage of bills to accommodate all customer transactions. The return value specifies whether it's feasible to provide all customers with the necessary change based on the bills at hand.

class Solution:
    def processTransactions(self, payments: List[int]) -> bool:
        count_of_five = 0
        count_of_ten = 0
        
        for payment in payments:
            if payment == 5:
                count_of_five += 1
            elif payment == 10:
                if count_of_five == 0:
                    return False
                count_of_five -= 1
                count_of_ten += 1
            else:
                if count_of_ten > 0 and count_of_five > 0:
                    count_of_five -= 1
                    count_of_ten -= 1
                elif count_of_five >= 3:
                    count_of_five -= 3
                else:
                    return False
        return True

The Python program provided tackles the problem of managing lemonade change transactions during sales. The main objective of the function processTransactions is to determine whether you can provide every customer with correct change, given a sequence of bill payments.

Here’s how the solution works:

• It starts by initializing two counters, count_of_five and count_of_ten, to track the number of $5 and $10 bills, respectively.

• The program then processes each payment in the list:

  • If it receives a $5 bill, it simply increments the count_of_five.
  • If a $10 bill is provided, the code checks for the availability of a $5 bill to give back as change. If a $5 bill is unavailable, it returns False, indicating it is impossible to provide the correct change.
  • For a $20 payment, the preferred change is one $10 and one $5 bill. If that’s not possible, it tries to use three $5 bills. If neither option is viable, it returns False.

• If the entire list of payments is processed without returning False, the function ends by returning True, indicating that it's possible to provide the correct change for all transactions.

The code effectively ensures that correct change handling is feasible, avoiding any scenario where a customer cannot be given the correct change. This implementation optimally utilizes available bills, prioritizing smaller denominations for higher flexibility in future transactions.