Calculator with Method Chaining - Practice Coding Problems

Calculator with Method Chaining - Problem

JavaScript Easy

Design a Calculator class that provides mathematical operations with method chaining support. The class should allow consecutive operations to be performed in a fluent interface style.

The Calculator constructor accepts an initial number which serves as the starting value for calculations.

Required Methods:

add(value) - Adds the given number to the result and returns the Calculator instance
subtract(value) - Subtracts the given number from the result and returns the Calculator instance
multiply(value) - Multiplies the result by the given number and returns the Calculator instance
divide(value) - Divides the result by the given number and returns the Calculator instance. Throws error "Division by zero is not allowed" if value is 0
power(value) - Raises the result to the power of the given number and returns the Calculator instance
getResult() - Returns the current result as a number

Solutions within 10⁻⁵ of the actual result are considered correct.

Input & Output

Example 1 — Basic Chaining

$ Input: Calculator(10).add(5).multiply(2).getResult()

› Output: 30

💡 Note: Start with 10, add 5 to get 15, multiply by 2 to get 30

Example 2 — Power Operation

$ Input: Calculator(2).power(3).subtract(3).getResult()

› Output: 5

💡 Note: Start with 2, raise to power 3 to get 8, subtract 3 to get 5

Example 3 — Division Error

$ Input: Calculator(10).divide(0)

› Output: Error: Division by zero is not allowed

💡 Note: Division by zero throws an error as specified

Constraints

-1000 ≤ initial value ≤ 1000
-100 ≤ operation values ≤ 100
1 ≤ number of operations ≤ 10
Division by zero throws error

Visualization

Tap to expand

Understanding the Visualization

Input

Initial value and sequence of operations

Process

Each method modifies result and returns this

Output

Final calculated result

Key Takeaway

🎯 Key Insight: Return 'this' from each method to create a fluent interface that allows natural method chaining

Asked in

G Google 25 a Amazon 18 M Microsoft 15

The key insight is to implement a fluent interface pattern where each method returns this to enable chaining. Best approach uses proper error handling for division by zero. Time: O(1), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Fluent Interface Pattern	O(1)	O(1)	Method chaining with proper error handling and validation
Basic Class Implementation	O(1)	O(1)	Simple calculator class with method chaining support

Fluent Interface Pattern — Algorithm Steps

Validate input parameters
Perform operation with error handling
Return this for chaining
Provide clear error messages

Visualization

Tap to expand

Step-by-Step Walkthrough

Validate Input

Check if input is valid number

Execute Operation

Perform calculation with error handling

Return Instance

Return this for continued chaining

Code -

solution.c — C

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

typedef struct {
    double result;
} Calculator;

Calculator* createCalculator(double initial) {
    Calculator* calc = (Calculator*)malloc(sizeof(Calculator));
    if (isnan(initial) || isinf(initial)) {
        printf("Initial value must be a valid number\n");
        exit(1);
    }
    calc->result = initial;
    return calc;
}

int validateNumber(double value) {
    return !isnan(value) && !isinf(value);
}

Calculator* add(Calculator* calc, double value) {
    if (!validateNumber(value)) {
        printf("Value must be a valid number\n");
        exit(1);
    }
    calc->result += value;
    return calc;
}

Calculator* subtract(Calculator* calc, double value) {
    if (!validateNumber(value)) {
        printf("Value must be a valid number\n");
        exit(1);
    }
    calc->result -= value;
    return calc;
}

Calculator* multiply(Calculator* calc, double value) {
    if (!validateNumber(value)) {
        printf("Value must be a valid number\n");
        exit(1);
    }
    calc->result *= value;
    return calc;
}

Calculator* divide(Calculator* calc, double value) {
    if (!validateNumber(value)) {
        printf("Value must be a valid number\n");
        exit(1);
    }
    if (value == 0) {
        printf("Division by zero is not allowed\n");
        exit(1);
    }
    calc->result /= value;
    return calc;
}

Calculator* power(Calculator* calc, double value) {
    if (!validateNumber(value)) {
        printf("Value must be a valid number\n");
        exit(1);
    }
    calc->result = pow(calc->result, value);
    return calc;
}

double getResult(Calculator* calc) {
    return calc->result;
}

double solution(double initial, double operations[][2], int opCount) {
    Calculator* calc = createCalculator(initial);
    for (int i = 0; i < opCount; i++) {
        int method = (int)operations[i][0];
        double value = operations[i][1];
        switch (method) {
            case 1: add(calc, value); break;
            case 2: subtract(calc, value); break;
            case 3: multiply(calc, value); break;
            case 4: divide(calc, value); break;
            case 5: power(calc, value); break;
        }
    }
    double result = getResult(calc);
    free(calc);
    return result;
}

int main() {
    double initial;
    scanf("%lf", &initial);
    
    double operations[100][2];
    int opCount = 0;
    
    double result = solution(initial, operations, opCount);
    printf("%f\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each operation is still constant time with validation

✓ Linear Growth

Space Complexity

O(1)

Only stores one result value regardless of validation

✓ Linear Space

24.1K Views

Medium Frequency

~15 min Avg. Time

892 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

Fluent Interface Pattern — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler