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.

Examples

Example 1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


**Input**
["Bank", "withdraw", "transfer", "deposit", "transfer", "withdraw"]
[[[10, 100, 20, 50, 30]], [3, 10], [5, 1, 20], [5, 20], [3, 4, 15], [10, 50]]
**Output**
[null, true, true, true, false, false]

**Explanation**
Bank bank = new Bank([10, 100, 20, 50, 30]);
bank.withdraw(3, 10);    // return true, account 3 has a balance of $20, so it is valid to withdraw $10.
                         // Account 3 has $20 - $10 = $10.
bank.transfer(5, 1, 20); // return true, account 5 has a balance of $30, so it is valid to transfer $20.
                         // Account 5 has $30 - $20 = $10, and account 1 has $10 + $20 = $30.
bank.deposit(5, 20);     // return true, it is valid to deposit $20 to account 5.
                         // Account 5 has $10 + $20 = $30.
bank.transfer(3, 4, 15); // return false, the current balance of account 3 is $10,
                         // so it is invalid to transfer $15 from it.
bank.withdraw(10, 50);   // return false, it is invalid because account 10 does not exist.

Constraints

n == balance.length
1 <= n, account, account1, account2 <= 10^5
0 <= balance[i], money <= 1012
At most 104 calls will be made to each function transfer, deposit, withdraw.

Solution

Method 1 – Array Simulation

Intuition

Use an array to store balances. For each operation, check account validity and balance, then update accordingly.

Approach

Store balances in an array (0-indexed, but accounts are 1-indexed).
For each operation, check if account(s) are valid (1 <= account <= n).
For withdraw/transfer, check if balance is sufficient.
Update balances as needed and return True/False.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


#include <vector>
using namespace std;
class Bank {
    vector<long long> bal;
    int n;
public:
    Bank(vector<long long>& balance) : bal(balance), n(balance.size()) {}
    bool valid(int acc) { return acc >= 1 && acc <= n; }
    bool transfer(int acc1, int acc2, long long money) {
        if (!valid(acc1) || !valid(acc2) || bal[acc1-1] < money) return false;
        bal[acc1-1] -= money; bal[acc2-1] += money; return true;
    }
    bool deposit(int acc, long long money) {
        if (!valid(acc)) return false;
        bal[acc-1] += money; return true;
    }
    bool withdraw(int acc, long long money) {
        if (!valid(acc) || bal[acc-1] < money) return false;
        bal[acc-1] -= money; return true;
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


class Bank {
    private long[] bal;
    private int n;
    public Bank(long[] balance) {
        bal = balance;
        n = balance.length;
    }
    private boolean valid(int acc) { return acc >= 1 && acc <= n; }
    public boolean transfer(int acc1, int acc2, long money) {
        if (!valid(acc1) || !valid(acc2) || bal[acc1-1] < money) return false;
        bal[acc1-1] -= money; bal[acc2-1] += money; return true;
    }
    public boolean deposit(int acc, long money) {
        if (!valid(acc)) return false;
        bal[acc-1] += money; return true;
    }
    public boolean withdraw(int acc, long money) {
        if (!valid(acc) || bal[acc-1] < money) return false;
        bal[acc-1] -= money; return true;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


class Bank:
    def __init__(self, balance):
        self.bal = balance
        self.n = len(balance)
    def valid(self, acc):
        return 1 <= acc <= self.n
    def transfer(self, acc1, acc2, money):
        if not self.valid(acc1) or not self.valid(acc2) or self.bal[acc1-1] < money:
            return False
        self.bal[acc1-1] -= money
        self.bal[acc2-1] += money
        return True
    def deposit(self, acc, money):
        if not self.valid(acc):
            return False
        self.bal[acc-1] += money
        return True
    def withdraw(self, acc, money):
        if not self.valid(acc) or self.bal[acc-1] < money:
            return False
        self.bal[acc-1] -= money
        return True

Complexity

⏰ Time complexity: O(1) per operation.
🧺 Space complexity: O(n) for the balances array.

Problem#

Examples#

Example 1#

Constraints#

Solution#

Method 1 – Array Simulation#

Intuition#

Approach#

Code#

Complexity#