Design an ATM Machine - Practice Coding Problems

Design an ATM Machine - Problem

Design an ATM Machine that simulates real ATM operations with banknote management.

Your ATM handles 5 denominations: $20, $50, $100, $200, and $500. The machine starts empty and supports two key operations:

🏦 Deposit: Add banknotes to the machine's inventory
💰 Withdraw: Dispense money using a greedy approach - always prioritize larger denominations first

Key Challenge: The withdrawal algorithm is greedy and inflexible. If the greedy approach fails (e.g., trying to use a $500 bill when only $200s would work), the entire transaction is rejected.

Example:
• Withdraw $300 with inventory: 2×$50, 1×$100, 1×$200
• ✅ Success: Uses 1×$200 + 1×$100 (greedy works)

• Withdraw $600 with inventory: 3×$200, 1×$500
• ❌ Failure: Tries 1×$500, needs $100 more, but can't break the constraint to use 3×$200 instead

Input & Output

example_1.py — Basic Operations

$ Input: atm = ATM() atm.deposit([0,0,1,2,1]) # 1×$100, 2×$200, 1×$500 result1 = atm.withdraw(600) # Try $600 result2 = atm.withdraw(300) # Try $300

› Output: [-1] [0, 0, 1, 1, 0]

💡 Note: First withdrawal fails because greedy tries 1×$500 leaving $100, but can't make $100 with remaining bills (only $200s available). Second withdrawal succeeds: 1×$200 + 1×$100 = $300.

example_2.py — Successful Greedy

$ Input: atm = ATM() atm.deposit([0,2,1,1,0]) # 2×$50, 1×$100, 1×$200 result = atm.withdraw(300)

› Output: [0, 0, 1, 1, 0]

💡 Note: Greedy works perfectly: uses 1×$200 + 1×$100 = $300. No need to use $50 bills.

example_3.py — Edge Case Empty

$ Input: atm = ATM() result = atm.withdraw(100)

› Output: [-1]

💡 Note: ATM is empty, cannot withdraw anything.

Constraints

1 ≤ banknotesCount[i] ≤ 10⁹
1 ≤ amount ≤ 10⁹
At most 5000 calls total to deposit and withdraw
The ATM starts empty
Withdrawal must use greedy strategy - no alternative approaches allowed

Visualization

Tap to expand

Understanding the Visualization

Deposit Phase

Add banknotes to inventory counters

Withdrawal Request

Start greedy algorithm from largest denomination

Greedy Selection

Use maximum possible of each denomination

Validation

Check if exact amount achieved, update or reject

Key Takeaway

🎯 Key Insight: The ATM implements a strict greedy strategy that prioritizes larger denominations. This approach is fast (O(1)) but inflexible - it will reject transactions that could succeed with different bill combinations.

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses a greedy algorithm that processes denominations from largest to smallest. For each denomination, use the maximum possible count without exceeding the target. The key insight is that this problem requires strict adherence to the greedy strategy - if it fails, the entire transaction is rejected, even if other valid combinations exist.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Algorithm (Optimal)	O(1)	O(1)	Use greedy approach: largest denominations first, fail fast if impossible
Naive Implementation with Validation	O(5^n)	O(5)	Try all possible combinations for withdrawal validation

Greedy Algorithm (Optimal) — Algorithm Steps

For deposit: Add all banknotes to respective counters
For withdrawal: Start from largest denomination ($500)
Use maximum possible count of current denomination
Move to next smaller denomination
If we can make exact change, update inventory and return counts
If impossible, return [-1] without changing inventory

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with $500

Try to use as many $500 bills as possible

Move to $200

Use remaining amount with $200 bills

Continue decreasing

Work down through $100, $50, $20

Check result

If remaining is 0, success; otherwise fail

Code -

solution.c — C

typedef struct {
    int banknotes[5];
    int values[5];
} ATM;

ATM* aTMCreate() {
    ATM* obj = (ATM*)malloc(sizeof(ATM));
    for (int i = 0; i < 5; i++) {
        obj->banknotes[i] = 0;
    }
    obj->values[0] = 20;
    obj->values[1] = 50;
    obj->values[2] = 100;
    obj->values[3] = 200;
    obj->values[4] = 500;
    return obj;
}

void aTMDeposit(ATM* obj, int* banknotesCount, int banknotesCountSize) {
    for (int i = 0; i < 5; i++) {
        obj->banknotes[i] += banknotesCount[i];
    }
}

int* aTMWithdraw(ATM* obj, int amount, int* returnSize) {
    int* result = (int*)malloc(sizeof(int) * 5);
    for (int i = 0; i < 5; i++) result[i] = 0;
    
    int remaining = amount;
    
    // Greedy approach: largest denominations first
    for (int i = 4; i >= 0; i--) {
        if (remaining >= obj->values[i] && obj->banknotes[i] > 0) {
            int count = (obj->banknotes[i] < remaining / obj->values[i]) ? 
                        obj->banknotes[i] : remaining / obj->values[i];
            result[i] = count;
            remaining -= count * obj->values[i];
        }
    }
    
    if (remaining == 0) {
        // Update inventory
        for (int i = 0; i < 5; i++) {
            obj->banknotes[i] -= result[i];
        }
        *returnSize = 5;
        return result;
    }
    
    // Failed - return [-1]
    free(result);
    result = (int*)malloc(sizeof(int));
    result[0] = -1;
    *returnSize = 1;
    return result;
}

void aTMFree(ATM* obj) {
    free(obj);
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Only 5 denominations, so constant time operations

✓ Linear Growth

Space Complexity

O(1)

Only need to store 5 banknote counts

✓ Linear Space

35.0K Views

Medium-High Frequency

~18 min Avg. Time

1.5K 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

Greedy Algorithm (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler