Calculator with Method Chaining - Practice Coding Problems

Calculator with Method Chaining - Problem

JavaScript Easy

Design a Calculator Class with Method Chaining

Your task is to create a Calculator class that supports method chaining for performing consecutive mathematical operations. This is a classic example of the Fluent Interface design pattern, commonly used in modern programming.

The calculator should:
• Accept an initial value in the constructor
• Support basic operations: add, subtract, multiply, divide, and power
• Allow chaining operations like calc.add(5).multiply(3).subtract(2)
• Provide a getResult() method to retrieve the final value
• Handle division by zero with proper error handling

Example:
let calc = new Calculator(10);
calc.add(5).multiply(2).subtract(10).getResult(); // Returns 20

This pattern is widely used in libraries like jQuery, Lodash, and many SQL query builders!

Input & Output

example_1.js — Basic Chaining

$ Input: const calc = new Calculator(10); calc.add(5).multiply(2).getResult();

› Output: 30

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

example_2.js — Complex Operations

$ Input: const calc = new Calculator(2); calc.power(3).subtract(3).divide(5).getResult();

› Output: 1

💡 Note: 2^3 = 8, subtract 3 to get 5, divide by 5 to get 1

example_3.js — Division by Zero

$ Input: const calc = new Calculator(10); calc.divide(0);

› Output: Error: Division by zero is not allowed

💡 Note: Division by zero throws an error as required

Constraints

Initial value can be any real number
Operation values can be any real number
Division by zero must throw an error
Results within 10^-5 of expected are considered correct
All methods except getResult() must return the Calculator instance

Visualization

Tap to expand

Understanding the Visualization

Raw Material

Initial value enters the assembly line

Addition Station

Adds specified value and passes result forward

Multiplication Station

Multiplies by specified value and continues the line

Final Product

GetResult() extracts the finished product from the line

Key Takeaway

🎯 Key Insight: Method chaining works by returning the same object instance ('this') from each method, allowing the next method to be called immediately without breaking the chain.

Asked in

G Google 35 f Meta 28 a Amazon 22 ⊞ Microsoft 18

The optimal approach uses the Fluent Interface design pattern where each method modifies the internal state and returns this (the calculator instance) to enable method chaining. This creates readable, chainable operations like calc.add(5).multiply(2).subtract(1).

Common Approaches

Approach	Time	Space	Notes
✓ Basic Class Implementation	O(1)	O(1)	Simple class with methods that return the instance for chaining

Basic Class Implementation — Algorithm Steps

Create a Calculator class with a constructor that accepts and stores the initial value
Implement each mathematical operation method (add, subtract, multiply, divide, power)
Each method should modify the stored result and return 'this' for chaining
Add error handling for division by zero
Implement getResult() to return the current value

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Calculator created with initial value 10

Add 5

Result becomes 15, returns calculator instance

Multiply by 2

Result becomes 30, returns calculator instance

Subtract 10

Result becomes 20, returns calculator instance

Get Result

Returns final value 20

Code -

solution.c — C

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

typedef struct {
    double result;
} Calculator;

Calculator* calculator_new(double initialValue) {
    Calculator* calc = (Calculator*)malloc(sizeof(Calculator));
    calc->result = initialValue;
    return calc;
}

Calculator* calculator_add(Calculator* calc, double value) {
    calc->result += value;
    return calc;
}

Calculator* calculator_subtract(Calculator* calc, double value) {
    calc->result -= value;
    return calc;
}

Calculator* calculator_multiply(Calculator* calc, double value) {
    calc->result *= value;
    return calc;
}

Calculator* calculator_divide(Calculator* calc, double value) {
    if (value == 0) {
        printf("Error: Division by zero is not allowed\n");
        return NULL;
    }
    calc->result /= value;
    return calc;
}

Calculator* calculator_power(Calculator* calc, double value) {
    calc->result = pow(calc->result, value);
    return calc;
}

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

void calculator_free(Calculator* calc) {
    free(calc);
}

int main() {
    Calculator* calc = calculator_new(10);
    calculator_add(calc, 5);
    calculator_multiply(calc, 2);
    calculator_subtract(calc, 10);
    double result = calculator_getResult(calc);
    printf("%.1f\n", result); // Output: 20.0
    calculator_free(calc);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each operation is performed in constant time

✓ Linear Growth

Space Complexity

O(1)

Only stores the current result value

✓ Linear Space

28.5K 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

Basic Class Implementation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler