Custom Exception Creator - Problem

Create custom exception classes for a banking application that can handle different types of errors that occur during banking operations.

Requirements:

Create InsufficientFundsError exception for when account balance is too low
Create InvalidAmountError exception for negative or zero transaction amounts
Create AccountLockedError exception for when account is locked/frozen

Each exception should:

Accept a custom error message in the constructor
Have a default message if none is provided
Be properly structured as exception classes

Implement a BankAccount class that uses these exceptions and a function that demonstrates their usage by attempting various operations and catching the exceptions.

Input & Output

Example 1 — Successful Withdrawal

$ Input: account_balance = 100, transaction_amount = 50

› Output: Success: Balance is now 50

💡 Note: Account has sufficient funds ($100), withdrawal of $50 succeeds, leaving balance of $50

Example 2 — Insufficient Funds

$ Input: account_balance = 100, transaction_amount = 150

› Output: InsufficientFundsError: Insufficient funds in account

💡 Note: Account balance ($100) is less than withdrawal amount ($150), triggers InsufficientFundsError

Example 3 — Invalid Amount

$ Input: account_balance = 100, transaction_amount = -50

› Output: InvalidAmountError: Invalid transaction amount

💡 Note: Negative transaction amount (-$50) is invalid, triggers InvalidAmountError

Constraints

1 ≤ account_balance ≤ 10⁶
-1000 ≤ transaction_amount ≤ 10⁶
Exception classes must inherit from base Exception class
Each exception must have default and custom message constructors

Visualization

Tap to expand

Asked in

M Microsoft 25 a Amazon 30 G Google 20 A Apple 15

The key insight is creating custom exception classes that inherit from the base Exception class and provide specific error handling for different banking scenarios. Best approach is Enhanced Exception Classes with error codes and context information. Time: O(1), Space: O(1)

Common Approaches

✓ Basic Exception Classes

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

Create three custom exception classes that inherit from the base Exception class. Each has a constructor that accepts a custom message and provides a default message if none is given.

Enhanced Exception Classes with Context

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

Enhanced exception classes that include error codes, additional context like current balance or requested amount, and more detailed error messages for better debugging and user experience.

Basic Exception Classes — Algorithm Steps

Define each exception class inheriting from Exception
Add constructors with optional custom messages
Implement BankAccount class using these exceptions
Create demonstration function with try-catch blocks

Visualization

Tap to expand

Step-by-Step Walkthrough

Create Exception Classes

Define InsufficientFundsError, InvalidAmountError, AccountLockedError

Implement Bank Account

Create BankAccount class that throws appropriate exceptions

Handle Exceptions

Catch specific exceptions and return descriptive messages

Code -

solution.c — C

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

typedef enum {
    NO_ERROR,
    INSUFFICIENT_FUNDS,
    INVALID_AMOUNT,
    ACCOUNT_LOCKED
} ErrorType;

typedef struct {
    ErrorType type;
    char message[100];
} BankError;

typedef struct {
    double balance;
    int locked;
} BankAccount;

BankAccount* createAccount(double balance) {
    BankAccount* account = malloc(sizeof(BankAccount));
    account->balance = balance;
    account->locked = 0;
    return account;
}

BankError withdraw(BankAccount* account, double amount) {
    BankError error = {NO_ERROR, ""};
    
    if (account->locked) {
        error.type = ACCOUNT_LOCKED;
        strcpy(error.message, "Account is locked");
        return error;
    }
    
    if (amount <= 0) {
        error.type = INVALID_AMOUNT;
        strcpy(error.message, "Invalid transaction amount");
        return error;
    }
    
    if (amount > account->balance) {
        error.type = INSUFFICIENT_FUNDS;
        strcpy(error.message, "Insufficient funds in account");
        return error;
    }
    
    account->balance -= amount;
    return error;
}

char* solution(int accountBalance, int transactionAmount) {
    static char result[200];
    BankAccount* account = createAccount(accountBalance);
    
    if (transactionAmount == -999) {
        account->locked = 1;
    }
    
    BankError error = withdraw(account, transactionAmount);
    
    if (error.type == NO_ERROR) {
        sprintf(result, "Success: Balance is now %d", (int)account->balance);
    } else {
        switch (error.type) {
            case INSUFFICIENT_FUNDS:
                sprintf(result, "InsufficientFundsError: %s", error.message);
                break;
            case INVALID_AMOUNT:
                sprintf(result, "InvalidAmountError: %s", error.message);
                break;
            case ACCOUNT_LOCKED:
                sprintf(result, "AccountLockedError: %s", error.message);
                break;
        }
    }
    
    free(account);
    return result;
}

int main() {
    int accountBalance, transactionAmount;
    scanf("%d", &accountBalance);
    scanf("%d", &transactionAmount);
    
    char* result = solution(accountBalance, transactionAmount);
    printf("%s\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Exception creation and throwing are constant time operations

✓ Linear Growth

Space Complexity

O(1)

Only storing exception objects and account state

✓ Linear Space

12.5K Views

Medium Frequency

~15 min Avg. Time

450 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

Custom Exception Creator - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Basic Exception Classes — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler