Calculator with Method Chaining

Problem

Design a Calculator class. The class should provide the mathematical operations of addition, subtraction, multiplication, division, and exponentiation. It should also allow consecutive operations to be performed using method chaining. The Calculator class constructor should accept a number which serves as the initial value of result.

Your Calculator class should have the following methods:

• add - This method adds the given number value to the result and returns the updated Calculator.
• subtract - This method subtracts the given number value from the result and returns the updated Calculator.
• multiply - This method multiplies the result by the given number value and returns the updated Calculator.
• divide - This method divides the result by the given number value and returns the updated Calculator. If the passed value is 0, an error "Division by zero is not allowed" should be thrown.
• power - This method raises the result to the power of the given number value and returns the updated Calculator.
• getResult - This method returns the result.

Solutions within 10-5 of the actual result are considered correct.

Examples

Example 1

Input: 
actions = ["Calculator", "add", "subtract", "getResult"], 
values = [10, 5, 7]
Output: 8
Explanation: 
new Calculator(10).add(5).subtract(7).getResult() // 10 + 5 - 7 = 8

Example 2

Input: 
actions = ["Calculator", "multiply", "power", "getResult"], 
values = [2, 5, 2]
Output: 100
Explanation: 
new Calculator(2).multiply(5).power(2).getResult() // (2 * 5) ^ 2 = 100

Example 3

Input: 
actions = ["Calculator", "divide", "getResult"], 
values = [20, 0]
Output: "Division by zero is not allowed"
Explanation: 
new Calculator(20).divide(0).getResult() // 20 / 0 

The error should be thrown because we cannot divide by zero.

Constraints

• actions is a valid JSON array of strings
• values is a valid JSON array of numbers
• 2 <= actions.length <= 2 * 10^4
• 1 <= values.length <= 2 * 104 - 1
• actions[i] is one of "Calculator", "add", "subtract", "multiply", "divide", "power", and "getResult"
• First action is always "Calculator"
• Last action is always "getResult"

Solution

Method 1 – Method Chaining with Error Handling

Intuition

We use a class to store the result and return this from each operation to allow chaining. For division, we throw an error if dividing by zero. The result is always updated in place, and getResult returns the current value.

Approach

1. Store the result as a property in the constructor.
2. Each method (add, subtract, multiply, divide, power) updates the result and returns this for chaining.
3. In divide, throw an error if the value is 0.
4. getResult returns the result.

Code

JavaScript

class Calculator {
  constructor(result) {
    this.result = result;
  }
  add(val) {
    this.result += val;
    return this;
  }
  subtract(val) {
    this.result -= val;
    return this;
  }
  multiply(val) {
    this.result *= val;
    return this;
  }
  divide(val) {
    if (val === 0) throw new Error("Division by zero is not allowed");
    this.result /= val;
    return this;
  }
  power(val) {
    this.result = Math.pow(this.result, val);
    return this;
  }
  getResult() {
    return this.result;
  }
}

TypeScript

class Calculator {
  private result: number;
  constructor(result: number) {
    this.result = result;
  }
  add(val: number): this {
    this.result += val;
    return this;
  }
  subtract(val: number): this {
    this.result -= val;
    return this;
  }
  multiply(val: number): this {
    this.result *= val;
    return this;
  }
  divide(val: number): this {
    if (val === 0) throw new Error("Division by zero is not allowed");
    this.result /= val;
    return this;
  }
  power(val: number): this {
    this.result = Math.pow(this.result, val);
    return this;
  }
  getResult(): number {
    return this.result;
  }
}

Complexity

• ⏰ Time complexity: O(1) per operation
• 🧺 Space complexity: O(1)