Simple Bank System

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.

Input & Output

Example 1 — Basic Operations

$ Input: balance = [10,100,20,50,30], operations = [["withdraw",3,10],["transfer",5,1,20],["deposit",5,20],["transfer",3,4,15],["withdraw",10,50]]

› Output: [true,true,true,false,false]

💡 Note: withdraw(3,10): Account 3 has 20, withdraw 10 → balance becomes 10, return true. transfer(5,1,20): Account 5 has 30, transfer 20 to account 1 → account 5: 10, account 1: 30, return true. deposit(5,20): Deposit 20 to account 5 → account 5: 30, return true. transfer(3,4,15): Account 3 has 10, insufficient balance for 15, return false. withdraw(10,50): Account 10 doesn't exist, return false.

Example 2 — Invalid Operations

$ Input: balance = [100], operations = [["withdraw",1,200],["transfer",1,2,50]]

› Output: [false,false]

💡 Note: withdraw(1,200): Account 1 has 100, insufficient balance for 200, return false. transfer(1,2,50): Account 2 doesn't exist (only 1 account), return false.

Example 3 — Deposit Only

$ Input: balance = [0,0,0], operations = [["deposit",1,100],["deposit",2,50],["deposit",3,25]]

› Output: [true,true,true]

💡 Note: All deposits to valid accounts succeed: account 1: 100, account 2: 50, account 3: 25.

Constraints

1 ≤ balance.length ≤ 10⁵
0 ≤ balance[i] ≤ 10¹²
1 ≤ account, account1, account2 ≤ n
1 ≤ money ≤ 10¹²
At most 10⁴ calls in total

Visualization

Tap to expand

Asked in

A Amazon 15 M Microsoft 12 G Google 8 🍎 Apple 6

The key insight is that account numbers are 1-indexed while the balance array is 0-indexed, requiring careful conversion. The optimal approach uses direct array access with proper validation for O(1) operations. Best approach stores balances in an array and validates each operation before execution. Time: O(1) per operation, Space: O(n) for storing balances.

Common Approaches

✓ Direct Implementation

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

Store balances in an array and implement each banking operation with proper validation. Check account bounds and sufficient balance before executing any transaction.

Optimized Validation

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

Create helper methods for account validation and balance checking to reduce code duplication and improve readability while maintaining same time complexity.

Direct Implementation — Algorithm Steps

Store account balances in array
For each operation, validate account numbers
Check sufficient balance for withdrawals/transfers
Update balances accordingly

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create bank with initial balances

Validate

Check account numbers and sufficient balance

Execute

Update balances and return success/failure

Code -

solution.c — C

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

typedef struct {
    long long* balance;
    int n;
} Bank;

Bank* bankCreate(long long* balance, int balanceSize) {
    Bank* bank = (Bank*)malloc(sizeof(Bank));
    bank->n = balanceSize;
    bank->balance = (long long*)malloc(balanceSize * sizeof(long long));
    
    for (int i = 0; i < balanceSize; i++) {
        bank->balance[i] = balance[i];
    }
    
    return bank;
}

int bankTransfer(Bank* bank, int account1, int account2, long long money) {
    if (account1 < 1 || account1 > bank->n || account2 < 1 || account2 > bank->n) {
        return 0;
    }
    
    if (bank->balance[account1 - 1] < money) {
        return 0;
    }
    
    bank->balance[account1 - 1] -= money;
    bank->balance[account2 - 1] += money;
    
    return 1;
}

int bankDeposit(Bank* bank, int account, long long money) {
    if (account < 1 || account > bank->n) {
        return 0;
    }
    
    bank->balance[account - 1] += money;
    
    return 1;
}

int bankWithdraw(Bank* bank, int account, long long money) {
    if (account < 1 || account > bank->n) {
        return 0;
    }
    
    if (bank->balance[account - 1] < money) {
        return 0;
    }
    
    bank->balance[account - 1] -= money;
    
    return 1;
}

void bankFree(Bank* bank) {
    free(bank->balance);
    free(bank);
}

int main() {
    char line[100000];
    
    // Read balance array
    if (fgets(line, sizeof(line), stdin) == NULL) return 1;
    
    long long balance[100000];
    int balanceSize = 0;
    
    char* ptr = line;
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') ptr++;
    
    while (*ptr && *ptr != ']') {
        while (*ptr == ' ' || *ptr == ',') ptr++;
        if (*ptr == ']' || *ptr == '\0') break;
        balance[balanceSize++] = strtoll(ptr, &ptr, 10);
    }
    
    Bank* bank = bankCreate(balance, balanceSize);
    
    // Read operations array
    if (fgets(line, sizeof(line), stdin) == NULL) return 1;
    
    printf("[");
    
    int firstResult = 1;
    ptr = line;
    int bracketDepth = 0;
    
    while (*ptr) {
        if (*ptr == '[') {
            bracketDepth++;
            if (bracketDepth == 2) {
                ptr++;
                
                // Parse operation
                char op[20];
                int opIdx = 0;
                
                // Skip to first quote
                while (*ptr && *ptr != '"') ptr++;
                if (*ptr == '"') ptr++;
                
                // Read operation name
                while (*ptr && *ptr != '"') {
                    op[opIdx++] = *ptr++;
                }
                op[opIdx] = '\0';
                
                if (*ptr == '"') ptr++;
                
                int result = 0;
                
                if (strcmp(op, "withdraw") == 0) {
                    while (*ptr && (*ptr == ',' || *ptr == ' ')) ptr++;
                    int account = (int)strtol(ptr, &ptr, 10);
                    while (*ptr && (*ptr == ',' || *ptr == ' ')) ptr++;
                    long long money = strtoll(ptr, &ptr, 10);
                    result = bankWithdraw(bank, account, money);
                } else if (strcmp(op, "deposit") == 0) {
                    while (*ptr && (*ptr == ',' || *ptr == ' ')) ptr++;
                    int account = (int)strtol(ptr, &ptr, 10);
                    while (*ptr && (*ptr == ',' || *ptr == ' ')) ptr++;
                    long long money = strtoll(ptr, &ptr, 10);
                    result = bankDeposit(bank, account, money);
                } else if (strcmp(op, "transfer") == 0) {
                    while (*ptr && (*ptr == ',' || *ptr == ' ')) ptr++;
                    int account1 = (int)strtol(ptr, &ptr, 10);
                    while (*ptr && (*ptr == ',' || *ptr == ' ')) ptr++;
                    int account2 = (int)strtol(ptr, &ptr, 10);
                    while (*ptr && (*ptr == ',' || *ptr == ' ')) ptr++;
                    long long money = strtoll(ptr, &ptr, 10);
                    result = bankTransfer(bank, account1, account2, money);
                }
                
                if (!firstResult) {
                    printf(",");
                }
                printf("%s", result ? "true" : "false");
                firstResult = 0;
                
                bracketDepth = 1;
            }
        } else if (*ptr == ']') {
            bracketDepth--;
        }
        ptr++;
    }
    
    printf("]\n");
    
    bankFree(bank);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each operation (transfer, deposit, withdraw) takes constant time with array access

✓ Linear Growth

Space Complexity

O(n)

Store n account balances in array

⚡ Linearithmic Space

32.0K Views

Medium Frequency

~15 min Avg. Time

845 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Direct Implementation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler