Banking System

Anthropic's "Banking System" interview question is a multi-stage coding challenge focused on OOP principles, data structures for account/transaction management, and simulation of banking operations like deposits, withdrawals, and transfers. It appears in their software engineering interviews, often as a live or take-home task that evolves in complexity.[7]

Problem Statement

Implement a banking system class (Bank) that manages multiple Account objects. Core requirements include:

• Creating accounts with unique IDs, initial balances, and owner names.
• Processing transactions: deposits (add funds), withdrawals (subtract funds with overdraft checks), and transfers (between accounts, handling failures like insufficient funds).
• Simulating concurrent transactions safely using thread-safe data structures (e.g., locks or concurrent collections).
• Additional layers often added: transaction history/logging per account, interest calculation simulation over time, account freezing/unfreezing, and batch transaction processing. The goal tests OOP (encapsulation, inheritance for account types like checking/savings), data structures (e.g., HashMap for accounts, Queue/List for history), and simulation (multi-threaded transaction execution with failure modes).[1][7]

Key Methods to Implement

` class Account { String id, owner; double balance; List<Transaction> history; // or Queue }

class Bank { Map<String, Account> accounts; boolean createAccount(String id, String owner, double initialBalance); boolean deposit(String id, double amount); boolean withdraw(String id, double amount); boolean transfer(String fromId, String toId, double amount); double getBalance(String id); List<Transaction> getHistory(String id); // Extensions: void applyInterest(double rate); void freezeAccount(String id); } ` Use synchronized methods or Locks for thread-safety in transfers. Transactions are immutable objects with type, amount, timestamp, status (success/fail).[7]

Input/Output Examples

No official examples exist publicly, but reconstructed from reports:

Example 1: Basic Operations ` Input: bank.createAccount("acc1", "Alice", 1000.0) bank.deposit("acc1", 500.0) // Returns true, balance=1500.0 bank.withdraw("acc1", 200.0) // Returns true, balance=1300.0 bank.transfer("acc1", "acc2", 300.0) // First create acc2, returns true

Output:

• getBalance("acc1") → 1000.0
• getHistory("acc1") → [Deposit(500), Withdraw(200), Transfer(-300)] **Example 2: Failure Case (Simulation)** Input: bank.withdraw("acc1", 2000.0) // balance=1300.0

Output: false (insufficient funds), history appends failed transaction **Concurrent Simulation Example:** Threads: T1: transfer("acc1", "acc2", 100) T2: withdraw("acc1", 50) // Race condition possible

Output: One succeeds atomically, other fails; no lost updates. ` // Visual of Bank class UML if available in context; here conceptual.[1]

Constraints

• Up to 10^5 accounts/transactions.
• Balances/amounts: 0 ≤ value ≤ 10^9, doubles with 2 decimal precision.
• Thread-safety for 100+ concurrent operations.
• Time: O(1) average for lookups/operations (HashMap), O(n) for history dumps.
• Space: O(n) for accounts + histories.
• Edge cases: Negative amounts, zero balance, non-existent accounts, overdrafts disallowed, concurrent modifications.[5][1][7]