Calculator with Method Chaining

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

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

✓ Basic Class Implementation

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

Implement a Calculator class where each operation method modifies the internal result and returns the instance itself to enable chaining. Store the current result in an instance variable and update it with each operation.

Fluent Interface Pattern

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

Enhanced implementation with input validation, proper error handling for division by zero, and optimized method chaining. Each method validates input and handles edge cases appropriately.

Basic Class Implementation — Algorithm Steps

Store initial value in instance variable
Each method performs operation on current result
Return 'this' to enable chaining
getResult() returns current value

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create calculator with initial value

Chain Operations

Each method returns 'this' for chaining

Get Result

Final result after all operations

Code -

solution.c — C

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

typedef struct {
    double result;
} Calculator;

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

// Custom power function to avoid linking issues with math library
double customPow(double base, double exponent) {
    if (exponent == 0) return 1.0;
    if (exponent == 1) return base;
    if (exponent == -1) return 1.0 / base;
    
    // Handle integer exponents
    if (exponent == (int)exponent) {
        double result = 1.0;
        int exp = (int)exponent;
        int isNegative = exp < 0;
        if (isNegative) exp = -exp;
        
        for (int i = 0; i < exp; i++) {
            result *= base;
        }
        
        return isNegative ? 1.0 / result : result;
    }
    
    // For non-integer exponents, use approximation
    // This is a simple implementation for basic cases
    if (base > 0) {
        // Use exp(exponent * ln(base)) approximation
        // For simplicity, handle common fractional powers
        if (exponent == 0.5) {
            // Square root approximation using Newton's method
            double x = base / 2.0;
            for (int i = 0; i < 10; i++) {
                x = (x + base / x) / 2.0;
            }
            return x;
        }
    }
    
    return base; // Fallback
}

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

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

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

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

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

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

typedef struct {
    char method[20];
    double value;
} Operation;

int parseOperations(char* line, Operation* operations) {
    int count = 0;
    int i = 1; // skip first [
    int len = strlen(line);
    
    while (i < len - 1 && count < 100) {
        if (line[i] == '[') {
            i++; // skip [
            if (line[i] == '"') {
                i++; // skip "
                int j = 0;
                while (line[i] != '"' && j < 19) {
                    operations[count].method[j++] = line[i++];
                }
                operations[count].method[j] = '\0';
                i++; // skip "
                i++; // skip ,
                
                char valueStr[20];
                j = 0;
                while (line[i] != ']' && j < 19) {
                    valueStr[j++] = line[i++];
                }
                valueStr[j] = '\0';
                
                operations[count].value = atof(valueStr);
                count++;
                i++; // skip ]
            }
        }
        i++;
    }
    return count;
}

double solution(double initial, Operation* operations, int opCount) {
    Calculator* calc = createCalculator(initial);
    for (int i = 0; i < opCount; i++) {
        if (strcmp(operations[i].method, "add") == 0) {
            add(calc, operations[i].value);
        } else if (strcmp(operations[i].method, "subtract") == 0) {
            subtract(calc, operations[i].value);
        } else if (strcmp(operations[i].method, "multiply") == 0) {
            multiply(calc, operations[i].value);
        } else if (strcmp(operations[i].method, "divide") == 0) {
            divide(calc, operations[i].value);
        } else if (strcmp(operations[i].method, "power") == 0) {
            power(calc, operations[i].value);
        }
    }
    double result = getResult(calc);
    free(calc);
    return result;
}

int main() {
    double initial;
    scanf("%lf", &initial);
    getchar();
    
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    Operation operations[100];
    int opCount = parseOperations(line, operations);
    
    double result = solution(initial, operations, opCount);
    printf("%g\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each operation is performed in constant time

✓ Linear Growth

Space Complexity

O(1)

Only stores one result value in the instance

✓ 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

Basic Class Implementation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler