Simple Bank System - Practice Coding Problems

Simple Bank System - Problem

You're building the core system for a modern digital bank that needs to handle millions of transactions daily. The bank manages n accounts numbered from 1 to n, where each account has an initial balance stored in a 0-indexed array.

Your mission: Implement a robust Bank class that can safely execute three types of financial operations:

💸 Transfer: Move money between two accounts
💰 Deposit: Add money to an account
🏧 Withdraw: Remove money from an account

Security Rules: A transaction is valid only if:

All account numbers are between 1 and n
The account has sufficient balance for withdrawals/transfers

Your system should return true for successful transactions and false for invalid ones, ensuring no money is lost or created!

Input & Output

example_1.py — Basic Operations

$ Input: Bank([10, 100, 20, 50, 30]) operations: deposit(5, 20), withdraw(3, 10), transfer(1, 2, 5)

› Output: deposit: true, withdraw: true, transfer: true

💡 Note: All operations are valid: account 5 gets $20 (30→50), account 3 loses $10 (20→10), and $5 moves from account 1 to 2 (10→5, 100→105)

example_2.py — Invalid Operations

$ Input: Bank([10, 100, 20, 50, 30]) operations: withdraw(6, 10), transfer(1, 6, 5), withdraw(1, 50)

› Output: withdraw: false, transfer: false, withdraw: false

💡 Note: Account 6 doesn't exist (invalid), transfer to invalid account fails, and account 1 has insufficient balance ($10 < $50)

example_3.py — Edge Cases

$ Input: Bank([100]) operations: withdraw(1, 100), deposit(1, 50), transfer(1, 1, 25)

› Output: withdraw: true, deposit: true, transfer: true

💡 Note: Single account bank: withdraw entire balance (100→0), deposit $50 (0→50), self-transfer $25 (no net change but valid)

Constraints

n == balance.length
1 ≤ n ≤ 10⁵
0 ≤ balance[i] ≤ 10¹²
1 ≤ account, account1, account2 ≤ n
0 ≤ money ≤ 10¹²
At most 10⁴ calls will be made to each function

Visualization

Tap to expand

Understanding the Visualization

Account Validation

First, check if the account number exists (between 1 and n) - like verifying a valid account number

Balance Verification

For withdrawals/transfers, ensure sufficient funds - like checking account balance before dispensing cash

Atomic Transaction

Update account balances simultaneously - like a secure database transaction that either completes fully or fails completely

Key Takeaway

🎯 Key Insight: The banking system achieves optimal performance through direct array indexing (O(1) access) combined with proper validation, making it suitable for high-frequency transaction processing.

Asked in

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

The optimal solution uses a simple array to store account balances with O(1) operations. Key insights: validate account numbers are in range [1, n], check sufficient balance before withdrawals/transfers, and update balances atomically. The design prioritizes simplicity and efficiency for a banking system that needs fast, reliable transactions.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Linear Search)	O(1) per operation	O(n)	Store balances in array, validate every operation with bounds checking

Brute Force (Linear Search) — Algorithm Steps

Store balances in an array during initialization
For each operation, validate account numbers are in valid range [1, n]
Check sufficient balance for withdraw/transfer operations
Update balances if validation passes
Return success/failure status

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Bank

Create array with initial balances for accounts 1 to n

Validate Account

Check if account number is within valid range [1, n]

Check Balance

Verify sufficient funds for withdraw/transfer operations

Execute Transaction

Update account balances if all validations pass

Code -

solution.c — C

typedef struct {
    long long* balances;
    int n;
} Bank;

Bank* bankCreate(long long* balance, int balanceSize) {
    Bank* bank = (Bank*)malloc(sizeof(Bank));
    bank->balances = (long long*)malloc(balanceSize * sizeof(long long));
    bank->n = balanceSize;
    
    for (int i = 0; i < balanceSize; i++) {
        bank->balances[i] = balance[i];
    }
    
    return bank;
}

bool isValidAccount(Bank* obj, int account) {
    return account >= 1 && account <= obj->n;
}

bool bankTransfer(Bank* obj, int account1, int account2, long long money) {
    if (!isValidAccount(obj, account1) || !isValidAccount(obj, account2)) {
        return false;
    }
    if (obj->balances[account1 - 1] < money) {
        return false;
    }
    
    obj->balances[account1 - 1] -= money;
    obj->balances[account2 - 1] += money;
    return true;
}

bool bankDeposit(Bank* obj, int account, long long money) {
    if (!isValidAccount(obj, account)) {
        return false;
    }
    
    obj->balances[account - 1] += money;
    return true;
}

bool bankWithdraw(Bank* obj, int account, long long money) {
    if (!isValidAccount(obj, account)) {
        return false;
    }
    if (obj->balances[account - 1] < money) {
        return false;
    }
    
    obj->balances[account - 1] -= money;
    return true;
}

void bankFree(Bank* obj) {
    free(obj->balances);
    free(obj);
}

Time & Space Complexity

Time Complexity

⏱️

O(1) per operation

Each operation involves constant-time array access and simple arithmetic

✓ Linear Growth

Space Complexity

O(n)

We store n account balances in the array

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~15 min Avg. Time

892 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

Brute Force (Linear Search) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler