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:
1 and n, andImplement 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.Example 1:
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.length1 <= n, account, account1, account2 <= 1050 <= balance[i], money <= 1012104 calls will be made to each function transfer, deposit, withdraw.The Simple Bank System problem focuses on designing a small banking simulation that supports operations like transfer, deposit, and withdraw. A practical approach is to store account balances in an array where each index represents a bank account. Since account numbers are typically 1-indexed in the problem, careful index handling is important.
For each operation, first validate whether the given account numbers exist. After validation, simulate the requested operation by updating the balances accordingly. For example, a transfer requires verifying both accounts and ensuring the sender has sufficient funds before adjusting both balances. Deposit and withdraw operations similarly update the stored balance after performing necessary checks.
This approach works efficiently because each operation only performs a few constant-time checks and updates. By directly accessing balances via indices, the system achieves O(1) time per operation with minimal additional memory.
| Approach | Time Complexity | Space Complexity |
|---|---|---|
| Array-based simulation of bank operations | O(1) per operation | O(n) |
Fireship
Use these hints if you're stuck. Try solving on your own first.
How do you determine if a transaction will fail?
Simply apply the operations if the transaction is valid.
Watch expert explanations and walkthroughs
Practice problems asked by these companies to ace your technical interviews.
Explore More ProblemsJot down your thoughts, approach, and key learnings
Design and simulation problems similar to Simple Bank System can appear in technical interviews, especially to test data structure usage and careful handling of edge cases. While the exact problem may vary, the underlying concepts are commonly assessed.
The optimal approach is to simulate the banking system using an array to store account balances. Each operation such as transfer, deposit, or withdraw performs constant-time validation and balance updates, resulting in O(1) time per operation.
Important edge cases include invalid account numbers, transfers involving non-existent accounts, and withdrawal or transfer attempts with insufficient balance. Proper validation must occur before updating balances.
An array is the most suitable data structure because account numbers map directly to indices, enabling constant-time access and updates. A hash table could also work but is unnecessary since accounts are sequentially indexed.