Checking if change can be provided in JavaScript

We need to write a JavaScript function that determines whether a shopkeeper can provide exact change to all customers. The shopkeeper starts with no money and sells items costing ?5, with customers paying using ?5, ?10, or ?20 notes.

Problem

A shopkeeper sells a single commodity which costs exactly ?5. Customers in a queue will purchase one unit each, paying with ?5, ?10, or ?20 notes. The shopkeeper starts with no money and must provide exact change to each customer.

The function should return true if all customers can receive proper change, false otherwise.

Change Requirements

• ?5 note: No change needed
• ?10 note: Requires ?5 change (need one ?5 note)
• ?20 note: Requires ?15 change (need one ?10 + one ?5, or three ?5 notes)

Example

const arr = [5, 5, 10, 10, 20];

const provideChanges = (arr = []) => {
    let fives = 0;
    let tens = 0;
    
    for(let i = 0; i < arr.length; i++) {
        switch(arr[i]) {
            case 5:
                fives += 1;
                break;
            case 10:
                if(fives <= 0) {
                    return false;  // Can't provide ?5 change
                }
                fives -= 1;
                tens += 1;
                break;
            default: // ?20 case
                if(tens >= 1 && fives >= 1) {
                    // Use one ?10 and one ?5 for ?15 change
                    tens -= 1;
                    fives -= 1;
                } else if(fives >= 3) {
                    // Use three ?5 notes for ?15 change
                    fives -= 3;
                } else {
                    return false;  // Can't provide ?15 change
                }
                break;
        }
    }
    return true;
};

console.log(provideChanges(arr));

false

How It Works

The algorithm tracks available ?5 and ?10 notes:

1. ?5 payment: Add to our ?5 collection
2. ?10 payment: Give back one ?5 note as change, add ?10 to collection
3. ?20 payment: Try to give ?15 change using either:
   • One ?10 + one ?5 note (preferred)
   • Three ?5 notes (if no ?10 available)

Step-by-Step Trace

const traceExample = [5, 5, 10, 10, 20];

console.log("Tracing customer payments:");
let fives = 0, tens = 0;

traceExample.forEach((payment, index) => {
    console.log(`Customer ${index + 1} pays ?${payment}`);
    
    if(payment === 5) {
        fives++;
        console.log(`  No change needed. Fives: ${fives}, Tens: ${tens}`);
    } else if(payment === 10) {
        if(fives > 0) {
            fives--;
            tens++;
            console.log(`  Give ?5 change. Fives: ${fives}, Tens: ${tens}`);
        } else {
            console.log(`  Cannot provide change! Need ?5 but have ${fives}`);
        }
    } else { // ?20
        if(tens >= 1 && fives >= 1) {
            tens--; fives--;
            console.log(`  Give ?10+?5 change. Fives: ${fives}, Tens: ${tens}`);
        } else if(fives >= 3) {
            fives -= 3;
            console.log(`  Give three ?5 change. Fives: ${fives}, Tens: ${tens}`);
        } else {
            console.log(`  Cannot provide ?15 change!`);
        }
    }
});

Tracing customer payments:
Customer 1 pays ?5
  No change needed. Fives: 1, Tens: 0
Customer 2 pays ?5
  No change needed. Fives: 2, Tens: 0
Customer 3 pays ?10
  Give ?5 change. Fives: 1, Tens: 1
Customer 4 pays ?10
  Give ?5 change. Fives: 0, Tens: 2
Customer 5 pays ?20
  Cannot provide ?15 change!

Test Cases

// Test different scenarios
console.log("Test Case 1:", provideChanges([5, 5, 5, 10, 20])); // true
console.log("Test Case 2:", provideChanges([5, 5, 10, 10, 20])); // false
console.log("Test Case 3:", provideChanges([5, 5, 5, 5, 20])); // true
console.log("Test Case 4:", provideChanges([10, 10])); // false

Test Case 1: true
Test Case 2: false
Test Case 3: true
Test Case 4: false

Conclusion

This greedy algorithm efficiently determines if exact change can be provided by tracking available denominations. The key insight is prioritizing ?10+?5 combination over three ?5 notes when making ?15 change, as it preserves more ?5 notes for future transactions.