Is Calculator with Method Chaining easy or hard?

Calculator with Method Chaining is categorized as an Easy problem because it mainly tests understanding of classes and method chaining. The implementation is short, and the complexity is constant time and constant space.

Calculator with Method Chaining Python/Java solution

Python implementations return self from each method, while Java implementations return this. Both maintain an internal value field that gets updated after every operation. The chaining behavior works the same in both languages and runs in O(1) time per operation.

How to solve Calculator with Method Chaining in O(1)?

Create a calculator class with a variable storing the current result. Each method updates that variable using the requested arithmetic operation and returns the same instance (self or this). Because every operation is a constant-time arithmetic update, the complexity remains O(1) per call.

What is the best approach for Calculator with Method Chaining?

The standard solution uses a class that stores the current value and returns the same instance from every arithmetic method. Each method performs the operation, updates the internal state, and returns self or this so calls can be chained. This design runs in O(1) time per operation and O(1) space.

Is Calculator with Method Chaining asked at Google/Amazon/Meta?

Method chaining and fluent interface design appear in object-oriented design interviews at companies like Amazon, Google, and Meta. The exact problem may vary, but the concept of returning the current object to enable chained API calls is a common design pattern interviewers expect candidates to understand.

What data structure is used in Calculator with Method Chaining?

The solution primarily relies on object-oriented class design rather than a traditional data structure. The class maintains a single numeric state variable and exposes methods that modify it while returning the instance to support chaining.

What is the time complexity of Calculator with Method Chaining?

Each calculator operation such as add, subtract, multiply, or divide performs a single arithmetic update on the stored value. That makes the time complexity O(1) per method call and the space complexity O(1) because only one numeric value is stored.

Description Solution Video 6:22

2726. Calculator with Method Chaining

Easy76.2% acceptance2 companies

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.

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⁴
1 <= values.length <= 2 * 10⁴ - 1
actions[i] is one of "Calculator", "add", "subtract", "multiply", "divide", "power", and "getResult"
First action is always "Calculator"
Last action is always "getResult"

Asked at 2 companies

Microsoft Bloomberg

6:22

Still stuck?Read 3 approaches, or watch a walkthrough.

Open solution

LanguageLoading editor…

1class Calculator {
  
  /** 
   * @param {number} value
   */
  constructor(value) {
      
  }
  
  /** 
   * @param {number} value
   * @return {Calculator}
   */
  add(value){
      
  }
  
  /** 
   * @param {number} value
   * @return {Calculator}
   */
  subtract(value){
      
  }
  
  /** 
   * @param {number} value
   * @return {Calculator}
   */  
  multiply(value) {
      
  }
  
  /** 
   * @param {number} value
   * @return {Calculator}
   */
  divide(value) {
      
  }
  
  /** 
   * @param {number} value
   * @return {Calculator}
   */
  power(value) {
      
  }
  
  /** 
   * @return {number}
   */
  getResult() {
      
  }
56}

Starter codeJavaScriptSpaces: 4

Examples

Case 1Case 2Case 3

Input

["Calculator", "add", "subtract", "getResult"]
[10, 5, 7]

Input

["Calculator", "multiply", "power", "getResult"]
[2, 5, 2]

Input

["Calculator", "divide", "getResult"]
[20, 0]

Your code is saved on this device.Solution