Off-by-one on range boundaries
Wrong move: Loop endpoints miss first/last candidate.
Usually fails on: Fails on minimal arrays and exact-boundary answers.
Fix: Re-derive loops from inclusive/exclusive ranges before coding.
Move from brute-force thinking to an efficient approach using array strategy.
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.Problem summary: 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
Start with the most direct exhaustive search. That gives a correctness anchor before optimizing.
Pattern signal: Array · Hash Map · Design
["Bank","withdraw","transfer","deposit","transfer","withdraw"] [[[10,100,20,50,30]],[3,10],[5,1,20],[5,20],[3,4,15],[10,50]]
design-an-atm-machine)Source-backed implementations are provided below for direct study and interview prep.
// Accepted solution for LeetCode #2043: Simple Bank System
class Bank {
private long[] balance;
private int n;
public Bank(long[] balance) {
this.balance = balance;
this.n = balance.length;
}
public boolean transfer(int account1, int account2, long money) {
if (account1 > n || account2 > n || balance[account1 - 1] < money) {
return false;
}
balance[account1 - 1] -= money;
balance[account2 - 1] += money;
return true;
}
public boolean deposit(int account, long money) {
if (account > n) {
return false;
}
balance[account - 1] += money;
return true;
}
public boolean withdraw(int account, long money) {
if (account > n || balance[account - 1] < money) {
return false;
}
balance[account - 1] -= money;
return true;
}
}
/**
* Your Bank object will be instantiated and called as such:
* Bank obj = new Bank(balance);
* boolean param_1 = obj.transfer(account1,account2,money);
* boolean param_2 = obj.deposit(account,money);
* boolean param_3 = obj.withdraw(account,money);
*/
// Accepted solution for LeetCode #2043: Simple Bank System
type Bank struct {
balance []int64
n int
}
func Constructor(balance []int64) Bank {
return Bank{balance, len(balance)}
}
func (this *Bank) Transfer(account1 int, account2 int, money int64) bool {
if account1 > this.n || account2 > this.n || this.balance[account1-1] < money {
return false
}
this.balance[account1-1] -= money
this.balance[account2-1] += money
return true
}
func (this *Bank) Deposit(account int, money int64) bool {
if account > this.n {
return false
}
this.balance[account-1] += money
return true
}
func (this *Bank) Withdraw(account int, money int64) bool {
if account > this.n || this.balance[account-1] < money {
return false
}
this.balance[account-1] -= money
return true
}
/**
* Your Bank object will be instantiated and called as such:
* obj := Constructor(balance);
* param_1 := obj.Transfer(account1,account2,money);
* param_2 := obj.Deposit(account,money);
* param_3 := obj.Withdraw(account,money);
*/
# Accepted solution for LeetCode #2043: Simple Bank System
class Bank:
def __init__(self, balance: List[int]):
self.balance = balance
self.n = len(balance)
def transfer(self, account1: int, account2: int, money: int) -> bool:
if account1 > self.n or account2 > self.n or self.balance[account1 - 1] < money:
return False
self.balance[account1 - 1] -= money
self.balance[account2 - 1] += money
return True
def deposit(self, account: int, money: int) -> bool:
if account > self.n:
return False
self.balance[account - 1] += money
return True
def withdraw(self, account: int, money: int) -> bool:
if account > self.n or self.balance[account - 1] < money:
return False
self.balance[account - 1] -= money
return True
# Your Bank object will be instantiated and called as such:
# obj = Bank(balance)
# param_1 = obj.transfer(account1,account2,money)
# param_2 = obj.deposit(account,money)
# param_3 = obj.withdraw(account,money)
// Accepted solution for LeetCode #2043: Simple Bank System
struct Bank {
balance: Vec<i64>,
}
/**
* `&self` means the method takes an immutable reference.
* If you need a mutable reference, change it to `&mut self` instead.
*/
impl Bank {
fn new(balance: Vec<i64>) -> Self {
Bank { balance }
}
fn transfer(&mut self, account1: i32, account2: i32, money: i64) -> bool {
let (account1, account2, n) = (account1 as usize, account2 as usize, self.balance.len());
if n < account1 || n < account2 {
return false;
}
if self.balance[account1 - 1] < money {
return false;
}
self.balance[account1 - 1] -= money;
self.balance[account2 - 1] += money;
true
}
fn deposit(&mut self, account: i32, money: i64) -> bool {
let (account, n) = (account as usize, self.balance.len());
if n < account {
return false;
}
self.balance[account - 1] += money;
true
}
fn withdraw(&mut self, account: i32, money: i64) -> bool {
let (account, n) = (account as usize, self.balance.len());
if n < account {
return false;
}
if self.balance[account - 1] < money {
return false;
}
self.balance[account - 1] -= money;
true
}
}
// Accepted solution for LeetCode #2043: Simple Bank System
class Bank {
balance: number[];
constructor(balance: number[]) {
this.balance = balance;
}
transfer(account1: number, account2: number, money: number): boolean {
if (
account1 > this.balance.length ||
account2 > this.balance.length ||
money > this.balance[account1 - 1]
)
return false;
this.balance[account1 - 1] -= money;
this.balance[account2 - 1] += money;
return true;
}
deposit(account: number, money: number): boolean {
if (account > this.balance.length) return false;
this.balance[account - 1] += money;
return true;
}
withdraw(account: number, money: number): boolean {
if (account > this.balance.length || money > this.balance[account - 1]) {
return false;
}
this.balance[account - 1] -= money;
return true;
}
}
/**
* Your Bank object will be instantiated and called as such:
* var obj = new Bank(balance)
* var param_1 = obj.transfer(account1,account2,money)
* var param_2 = obj.deposit(account,money)
* var param_3 = obj.withdraw(account,money)
*/
Use this to step through a reusable interview workflow for this problem.
Use a simple list or array for storage. Each operation (get, put, remove) requires a linear scan to find the target element — O(n) per operation. Space is O(n) to store the data. The linear search makes this impractical for frequent operations.
Design problems target O(1) amortized per operation by combining data structures (hash map + doubly-linked list for LRU, stack + min-tracking for MinStack). Space is always at least O(n) to store the data. The challenge is achieving constant-time operations through clever structure composition.
Review these before coding to avoid predictable interview regressions.
Wrong move: Loop endpoints miss first/last candidate.
Usually fails on: Fails on minimal arrays and exact-boundary answers.
Fix: Re-derive loops from inclusive/exclusive ranges before coding.
Wrong move: Zero-count keys stay in map and break distinct/count constraints.
Usually fails on: Window/map size checks are consistently off by one.
Fix: Delete keys when count reaches zero.