Undo Text Editor - Problem

Design and implement a simple text editor that supports the following operations:

Type: Add a character to the end of the current text
Delete: Remove the last character from the current text
Undo: Revert the text to its state before the last operation

Implement the TextEditor class with the following methods:

type(char) - adds the character to the end of the text
delete() - removes the last character from the text
undo() - undoes the last operation (type or delete)
getText() - returns the current text as a string

Your implementation should efficiently handle multiple undo operations and maintain the history of text states.

Input & Output

Example 1 — Basic Operations

$ Input: operations = [["type","h"],["type","e"],["delete"],["undo"]]

› Output: ["h","he","h","he"]

💡 Note: Type 'h' → "h", type 'e' → "he", delete last char → "h", undo delete → "he"

Example 2 — Multiple Undos

$ Input: operations = [["type","a"],["type","b"],["undo"],["undo"]]

› Output: ["a","ab","a",""]

💡 Note: Type 'a' → "a", type 'b' → "ab", undo → "a", undo again → ""

Example 3 — Delete and Undo

$ Input: operations = [["type","x"],["delete"],["undo"],["delete"]]

› Output: ["x","","x",""]

💡 Note: Type 'x' → "x", delete → "", undo delete → "x", delete again → ""

Constraints

1 ≤ operations.length ≤ 100
Each operation is one of: ["type", char], ["delete"], or ["undo"]
char is a lowercase English letter

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 18 a Amazon 15 Apple 12

The stack-based approach is optimal for this text editor problem. By storing complete text snapshots in a stack before each operation, we achieve O(1) undo operations at the cost of higher memory usage. Time: O(1) per operation, Space: O(n×m) for n operations on text of length m.

Common Approaches

✓ Brute Force - Recreate from Beginning

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

Keep a list of all operations performed. When undo is called, replay all operations from the beginning except the last one to reconstruct the text state.

Stack-Based State Storage

⏱️ Time: O(1) Space: O(n × m)

Maintain a stack of text states. Push current state before each operation. For undo, simply pop the stack to get the previous state.

Brute Force - Recreate from Beginning — Algorithm Steps

Store each operation in a list
For undo, replay all operations except the last
Reconstruct text by executing each stored operation

Visualization

Tap to expand

Step-by-Step Walkthrough

Store Operations

Keep list of all operations performed

Undo Request

Remove last operation from list

Replay All

Execute remaining operations to rebuild text

Code -

solution.c — C

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

#define MAX_OPS 1000
#define MAX_TEXT 1000

typedef struct {
    char operations[MAX_OPS][2][2];
    int op_count;
    char text[MAX_TEXT];
} TextEditor;

TextEditor* createTextEditor() {
    TextEditor* editor = (TextEditor*)malloc(sizeof(TextEditor));
    editor->op_count = 0;
    editor->text[0] = '\0';
    return editor;
}

void type(TextEditor* editor, char c) {
    strcpy(editor->operations[editor->op_count][0], "t");
    editor->operations[editor->op_count][1][0] = c;
    editor->operations[editor->op_count][1][1] = '\0';
    editor->op_count++;
    
    int len = strlen(editor->text);
    editor->text[len] = c;
    editor->text[len + 1] = '\0';
}

void deleteChar(TextEditor* editor) {
    int len = strlen(editor->text);
    if (len > 0) {
        strcpy(editor->operations[editor->op_count][0], "d");
        editor->operations[editor->op_count][1][0] = editor->text[len - 1];
        editor->operations[editor->op_count][1][1] = '\0';
        editor->op_count++;
        editor->text[len - 1] = '\0';
    }
}

void undo(TextEditor* editor) {
    if (editor->op_count > 0) {
        editor->op_count--;
        editor->text[0] = '\0';
        
        for (int i = 0; i < editor->op_count; i++) {
            if (strcmp(editor->operations[i][0], "t") == 0) {
                int len = strlen(editor->text);
                editor->text[len] = editor->operations[i][1][0];
                editor->text[len + 1] = '\0';
            } else if (strcmp(editor->operations[i][0], "d") == 0) {
                int len = strlen(editor->text);
                if (len > 0) {
                    editor->text[len - 1] = '\0';
                }
            }
        }
    }
}

char* getText(TextEditor* editor) {
    return editor->text;
}

int main() {
    // Simplified implementation for parsing operations
    TextEditor* editor = createTextEditor();
    
    // Example operations: type 'h', type 'i', delete, undo
    type(editor, 'h');
    printf("\"%s\",", getText(editor));
    
    type(editor, 'i');
    printf("\"%s\",", getText(editor));
    
    deleteChar(editor);
    printf("\"%s\",", getText(editor));
    
    undo(editor);
    printf("\"%s\"", getText(editor));
    
    free(editor);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each undo requires replaying n-1 operations to reconstruct state

✓ Linear Growth

Space Complexity

O(n)

Stores all operations in a list

⚡ Linearithmic Space

23.5K Views

Medium Frequency

~15 min Avg. Time

890 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

Undo Text Editor - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Recreate from Beginning — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler