Simple Bank System - Practice Coding Problems

Simple Bank System - Problem

You have been tasked with writing a program for a popular bank that will automate all its incoming transactions (transfer, deposit, and withdraw). The bank has n accounts numbered from 1 to n. The initial balance of each account is stored in a 0-indexed integer array balance, with the (i + 1)th account having an initial balance of balance[i].

Execute all the valid transactions. A transaction is valid if:

The given account number(s) are between 1 and n, and
The amount of money withdrawn or transferred from is less than or equal to the balance of the account.

Implement the Bank class:

Bank(long[] balance) Initializes the object with the 0-indexed integer array balance.
boolean transfer(int account1, int account2, long money) Transfers money dollars from the account numbered account1 to the account numbered account2. Return true if the transaction was successful, false otherwise.
boolean deposit(int account, long money) Deposit money dollars into the account numbered account. Return true if the transaction was successful, false otherwise.
boolean withdraw(int account, long money) Withdraw money dollars from the account numbered account. Return true if the transaction was successful, false otherwise.

Input & Output

Example 1 — Basic Operations

$ Input: balance = [10,100,20,50,30], operations = [["withdraw",3,10],["transfer",5,1,20],["deposit",5,20],["transfer",3,4,15],["withdraw",10,50]]

› Output: [true,true,true,false,false]

💡 Note: withdraw(3,10): Account 3 has 20, withdraw 10 → balance becomes 10, return true. transfer(5,1,20): Account 5 has 30, transfer 20 to account 1 → account 5: 10, account 1: 30, return true. deposit(5,20): Deposit 20 to account 5 → account 5: 30, return true. transfer(3,4,15): Account 3 has 10, insufficient balance for 15, return false. withdraw(10,50): Account 10 doesn't exist, return false.

Example 2 — Invalid Operations

$ Input: balance = [100], operations = [["withdraw",1,200],["transfer",1,2,50]]

› Output: [false,false]

💡 Note: withdraw(1,200): Account 1 has 100, insufficient balance for 200, return false. transfer(1,2,50): Account 2 doesn't exist (only 1 account), return false.

Example 3 — Deposit Only

$ Input: balance = [0,0,0], operations = [["deposit",1,100],["deposit",2,50],["deposit",3,25]]

› Output: [true,true,true]

💡 Note: All deposits to valid accounts succeed: account 1: 100, account 2: 50, account 3: 25.

Constraints

1 ≤ balance.length ≤ 10⁵
0 ≤ balance[i] ≤ 10¹²
1 ≤ account, account1, account2 ≤ n
1 ≤ money ≤ 10¹²
At most 10⁴ calls in total

Visualization

Tap to expand

Understanding the Visualization

Input

Initial account balances and list of operations

Process

Validate and execute each banking operation

Output

Boolean array indicating success/failure of each operation

Key Takeaway

🎯 Key Insight: Account validation and balance checking are crucial for secure banking operations

Asked in

A Amazon 15 M Microsoft 12 G Google 8 🍎 Apple 6

The key insight is that account numbers are 1-indexed while the balance array is 0-indexed, requiring careful conversion. The optimal approach uses direct array access with proper validation for O(1) operations. Best approach stores balances in an array and validates each operation before execution. Time: O(1) per operation, Space: O(n) for storing balances.

Common Approaches

Approach	Time	Space	Notes
✓ Direct Implementation	O(1)	O(n)	Implement each operation with basic validation and balance updates
Optimized Validation	O(1)	O(n)	Pre-validate account bounds once and use helper methods

Direct Implementation — Algorithm Steps

Store account balances in array
For each operation, validate account numbers
Check sufficient balance for withdrawals/transfers
Update balances accordingly

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create bank with initial balances

Validate

Check account numbers and sufficient balance

Execute

Update balances and return success/failure

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

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

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

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

bool bankDeposit(Bank* bank, int account, long long money) {
    if (account < 1 || account > bank->n) {
        return false;
    }
    bank->balance[account - 1] += money;
    return true;
}

bool bankWithdraw(Bank* bank, int account, long long money) {
    if (account < 1 || account > bank->n) {
        return false;
    }
    if (bank->balance[account - 1] < money) {
        return false;
    }
    bank->balance[account - 1] -= money;
    return true;
}

int main() {
    // Simple parsing for demonstration
    long long balance[] = {10, 100, 20, 50, 30};
    int balanceSize = 5;
    
    Bank* bank = bankCreate(balance, balanceSize);
    
    // Example operations
    printf("[%s,", bankWithdraw(bank, 3, 10) ? "true" : "false");
    printf("%s,", bankTransfer(bank, 5, 1, 20) ? "true" : "false");
    printf("%s,", bankDeposit(bank, 5, 20) ? "true" : "false");
    printf("%s,", bankTransfer(bank, 3, 4, 15) ? "true" : "false");
    printf("%s]\n", bankWithdraw(bank, 10, 50) ? "true" : "false");
    
    free(bank->balance);
    free(bank);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each operation (transfer, deposit, withdraw) takes constant time with array access

✓ Linear Growth

Space Complexity

O(n)

Store n account balances in array

⚡ Linearithmic Space

32.0K Views

Medium Frequency

~15 min Avg. Time

845 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

Direct Implementation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler