Command Pattern Calculator - Problem

Design and implement a calculator using the Command Pattern that supports basic arithmetic operations with undo and redo functionality.

Your calculator should support the following operations:

ADD - Add a number to current result
SUBTRACT - Subtract a number from current result
MULTIPLY - Multiply current result by a number
DIVIDE - Divide current result by a number
UNDO - Undo the last operation
REDO - Redo the last undone operation

Each operation is represented as a string array: ["ADD", "5"] or ["UNDO"]

The calculator starts with a result of 0. Return the final result after executing all commands.

Input & Output

Example 1 — Basic Operations with Undo

$ Input: commands = [["ADD", "10"], ["MULTIPLY", "2"], ["UNDO"], ["ADD", "5"]]

› Output: 15

💡 Note: Start: 0 → ADD 10: 10 → MULTIPLY 2: 20 → UNDO: 10 → ADD 5: 15

Example 2 — Undo and Redo Operations

$ Input: commands = [["ADD", "8"], ["SUBTRACT", "3"], ["UNDO"], ["REDO"]]

› Output: 5

💡 Note: Start: 0 → ADD 8: 8 → SUBTRACT 3: 5 → UNDO: 8 → REDO: 5

Example 3 — Multiple Undos

$ Input: commands = [["ADD", "12"], ["DIVIDE", "3"], ["MULTIPLY", "5"], ["UNDO"], ["UNDO"]]

› Output: 4

💡 Note: Start: 0 → ADD 12: 12 → DIVIDE 3: 4 → MULTIPLY 5: 20 → UNDO: 4 → UNDO: 12

Constraints

1 ≤ commands.length ≤ 1000
Each operation value is between -1000 and 1000
Division by zero will not occur
UNDO will only be called when there are operations to undo
REDO will only be called when there are operations to redo

Visualization

Tap to expand

Asked in

G Google 42 M Microsoft 38 a Amazon 35 A Adobe 28

The Command Pattern solution creates command objects that encapsulate both execution and undo logic. Each command knows how to execute itself and how to reverse its effects. We maintain two stacks - one for executed commands (for undo) and one for undone commands (for redo). Time: O(n), Space: O(n)

Common Approaches

✓ Command Pattern with Undo/Redo Stacks

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

Implement proper Command Pattern with command objects that know how to execute and undo themselves. Maintain separate stacks for executed commands and undone commands that can be redone.

Replay All Operations

⏱️ Time: O(n²) Space: O(n)

Keep all operations in a list. When undo is encountered, replay all previous operations except the last one. When redo is encountered, restore the previously undone operation.

Command Pattern with Undo/Redo Stacks — Algorithm Steps

Create command objects that can execute and undo themselves
Maintain a stack of executed commands for undo
Maintain a stack of undone commands for redo
Execute commands directly, updating result in real-time

Visualization

Tap to expand

Step-by-Step Walkthrough

Create Command

Each operation becomes a command object

Execute & Store

Execute command and push to undo stack

Undo/Redo

Pop from stack and call undo/execute method

Code -

solution.c — C

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

typedef struct {
    char type[20];
    int value;
    int prevResult;
} Command;

int executeCommand(Command* cmd, int result) {
    if (strcmp(cmd->type, "ADD") == 0) {
        return result + cmd->value;
    } else if (strcmp(cmd->type, "SUBTRACT") == 0) {
        return result - cmd->value;
    } else if (strcmp(cmd->type, "MULTIPLY") == 0) {
        cmd->prevResult = result;
        return result * cmd->value;
    } else if (strcmp(cmd->type, "DIVIDE") == 0) {
        cmd->prevResult = result;
        return result / cmd->value;
    }
    return result;
}

int undoCommand(Command* cmd, int result) {
    if (strcmp(cmd->type, "ADD") == 0) {
        return result - cmd->value;
    } else if (strcmp(cmd->type, "SUBTRACT") == 0) {
        return result + cmd->value;
    } else if (strcmp(cmd->type, "MULTIPLY") == 0 || strcmp(cmd->type, "DIVIDE") == 0) {
        return cmd->prevResult;
    }
    return result;
}

int solution(char*** commands, int numCommands) {
    int result = 0;
    Command* undoStack = malloc(numCommands * sizeof(Command));
    Command* redoStack = malloc(numCommands * sizeof(Command));
    int undoCount = 0, redoCount = 0;
    
    for (int i = 0; i < numCommands; i++) {
        if (strcmp(commands[i][0], "UNDO") == 0) {
            if (undoCount > 0) {
                Command cmd = undoStack[--undoCount];
                result = undoCommand(&cmd, result);
                redoStack[redoCount++] = cmd;
            }
        } else if (strcmp(commands[i][0], "REDO") == 0) {
            if (redoCount > 0) {
                Command cmd = redoStack[--redoCount];
                result = executeCommand(&cmd, result);
                undoStack[undoCount++] = cmd;
            }
        } else {
            Command cmd;
            strcpy(cmd.type, commands[i][0]);
            cmd.value = atoi(commands[i][1]);
            cmd.prevResult = 0;
            
            result = executeCommand(&cmd, result);
            undoStack[undoCount++] = cmd;
            redoCount = 0;
        }
    }
    
    free(undoStack);
    free(redoStack);
    return result;
}

int main() {
    // Parse input (simplified)
    int result = 0; // Would parse and call solution
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each operation (including undo/redo) takes O(1) time, total O(n) for n commands

✓ Linear Growth

Space Complexity

O(n)

Stores command objects in undo and redo stacks

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~35 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

Command Pattern Calculator - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Command Pattern with Undo/Redo Stacks — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler