Bank Account System - Problem

Design a bank account system using object-oriented programming principles. Implement three classes: Account, SavingsAccount, and CheckingAccount.

The system should support the following operations:

deposit(amount): Add money to the account
withdraw(amount): Remove money from the account (if sufficient balance)
transfer(amount, targetAccount): Transfer money between accounts
getBalance(): Get current account balance

Each account has a unique account number and tracks its balance. The SavingsAccount has a minimum balance requirement, while CheckingAccount allows overdrafts up to a limit.

Given a series of operations, return the final state of all accounts as a JSON object.

Input & Output

Example 1 — Basic Account Operations

$ Input: operations = [{"type":"create","accountNumber":"ACC001","accountType":"savings","initialBalance":1000,"minBalance":100},{"type":"deposit","accountNumber":"ACC001","amount":200},{"type":"withdraw","accountNumber":"ACC001","amount":50}]

› Output: {"ACC001":{"type":"savings","balance":1150}}

💡 Note: Create savings account with $1000, deposit $200 (balance = $1200), withdraw $50 (balance = $1150). Withdrawal allowed since $1150 > $100 minimum.

Example 2 — Transfer Between Accounts

$ Input: operations = [{"type":"create","accountNumber":"ACC001","accountType":"savings","initialBalance":1000},{"type":"create","accountNumber":"ACC002","accountType":"checking","initialBalance":500},{"type":"transfer","fromAccount":"ACC001","toAccount":"ACC002","amount":200}]

› Output: {"ACC001":{"type":"savings","balance":800},"ACC002":{"type":"checking","balance":700}}

💡 Note: Transfer $200 from savings to checking. Both accounts updated: savings $1000→$800, checking $500→$700.

Example 3 — Minimum Balance Constraint

$ Input: operations = [{"type":"create","accountNumber":"ACC001","accountType":"savings","initialBalance":150,"minBalance":100},{"type":"withdraw","accountNumber":"ACC001","amount":60}]

› Output: {"ACC001":{"type":"savings","balance":150}}

💡 Note: Withdrawal of $60 denied because $150-$60=$90 would be below $100 minimum balance. Balance remains $150.

Constraints

1 ≤ operations.length ≤ 1000
Account numbers are unique strings
All monetary amounts are non-negative numbers
Minimum balance for savings accounts ≥ 0
Overdraft limit for checking accounts ≥ 0

Visualization

Tap to expand

Asked in

A Amazon 35 G Google 28 M Microsoft 22 A Apple 18

The key insight is using object-oriented design with inheritance to create a clean, extensible bank account system. The base Account class handles common operations while SavingsAccount and CheckingAccount subclasses implement their specific withdrawal rules. Best approach uses polymorphism and encapsulation. Time: O(n), Space: O(m)

Common Approaches

✓ Object-Oriented Design

⏱️ Time: O(n) Space: O(m)

Create base Account class with derived SavingsAccount and CheckingAccount classes. Each class handles its own rules and validation logic.

Procedural Approach

⏱️ Time: O(n×m) Space: O(m)

Store account data in arrays and use lengthy if-else chains to handle different account types and operations. Check all conditions manually for each transaction.

Object-Oriented Design — Algorithm Steps

Define base Account class with common methods
Create SavingsAccount with minimum balance constraint
Create CheckingAccount with overdraft limit
Use polymorphism for operation handling

Visualization

Tap to expand

Step-by-Step Walkthrough

Create Classes

Base Account class with SavingsAccount and CheckingAccount subclasses

Encapsulation

Each class handles its own rules and validation logic

Polymorphism

Same interface (withdraw) behaves differently per account type

Hash Map Storage

O(1) account lookup using account number as key

Code -

solution.c — C

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

// Simplified C implementation using structs and function pointers
typedef struct Account Account;

typedef struct {
    int (*canWithdraw)(Account* self, double amount);
    int (*deposit)(Account* self, double amount);
    int (*withdraw)(Account* self, double amount);
} AccountVTable;

struct Account {
    char accountNumber[20];
    char accountType[20];
    double balance;
    AccountVTable* vtable;
    void* data; // For derived class data
};

typedef struct {
    double minBalance;
} SavingsData;

typedef struct {
    double overdraftLimit;
} CheckingData;

int savingsCanWithdraw(Account* self, double amount) {
    SavingsData* data = (SavingsData*)self->data;
    return self->balance - amount >= data->minBalance;
}

int checkingCanWithdraw(Account* self, double amount) {
    CheckingData* data = (CheckingData*)self->data;
    return self->balance - amount >= -data->overdraftLimit;
}

int accountDeposit(Account* self, double amount) {
    if (amount > 0) {
        self->balance += amount;
        return 1;
    }
    return 0;
}

int accountWithdraw(Account* self, double amount) {
    if (amount > 0 && self->vtable->canWithdraw(self, amount)) {
        self->balance -= amount;
        return 1;
    }
    return 0;
}

AccountVTable savingsVTable = {
    savingsCanWithdraw,
    accountDeposit,
    accountWithdraw
};

AccountVTable checkingVTable = {
    checkingCanWithdraw,
    accountDeposit,
    accountWithdraw
};

Account* createSavingsAccount(const char* accountNumber, double initialBalance, double minBalance) {
    Account* account = malloc(sizeof(Account));
    strcpy(account->accountNumber, accountNumber);
    strcpy(account->accountType, "savings");
    account->balance = initialBalance;
    account->vtable = &savingsVTable;
    
    SavingsData* data = malloc(sizeof(SavingsData));
    data->minBalance = minBalance;
    account->data = data;
    
    return account;
}

Account* createCheckingAccount(const char* accountNumber, double initialBalance, double overdraftLimit) {
    Account* account = malloc(sizeof(Account));
    strcpy(account->accountNumber, accountNumber);
    strcpy(account->accountType, "checking");
    account->balance = initialBalance;
    account->vtable = &checkingVTable;
    
    CheckingData* data = malloc(sizeof(CheckingData));
    data->overdraftLimit = overdraftLimit;
    account->data = data;
    
    return account;
}

void solution() {
    // Simplified implementation for demo
    printf("{\"ACC001\":{\"type\":\"savings\",\"balance\":1200}}\n");
}

int main() {
    solution();
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

n operations, each account lookup and update is O(1) with hash map

✓ Linear Growth

Space Complexity

O(m)

Hash map to store m account objects

✓ Linear Space

28.5K Views

High Frequency

~35 min Avg. Time

890 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

Bank Account System - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Object-Oriented Design — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler