Design a Text Editor - Practice Coding Problems

Design a Text Editor - Problem

Linked List String Stack Design Simulation Doubly-Linked List Hard

Design a Text Editor with cursor navigation and text manipulation capabilities.

You need to implement a text editor that supports a movable cursor with the following operations:

Add text at the cursor position
Delete text to the left of the cursor (backspace functionality)
Move cursor left or right within the text

The cursor behaves like a real text editor - it stays within bounds 0 ≤ cursor.position ≤ text.length and deletion only affects characters to the left.

Example:
Starting with empty text "" and cursor at position 0:
• addText("hello") → text becomes "hello|" (cursor at end)
• cursorLeft(2) → cursor moves to "hel|lo"
• addText("p") → text becomes "help|lo"
• deleteText(1) → text becomes "hel|lo"

Input & Output

example_1.py — Basic Operations

$ Input: ["TextEditor", "addText", "deleteText", "addText", "cursorRight", "cursorLeft", "deleteText", "cursorLeft", "cursorRight"] [[], ["leetcode"], [4], ["practice"], [3], [8], [10], [2], [6]]

› Output: [null, null, 4, null, "etpractice", "leet", 4, "", "practi"]

💡 Note: TextEditor textEditor = new TextEditor(); // current text is "". cursor is at index 0. textEditor.addText("leetcode"); // current text is "leetcode". cursor is at index 8. textEditor.deleteText(4); // return 4. current text is "leet". cursor is at index 4. textEditor.addText("practice"); // current text is "leetpractice". cursor is at index 12. textEditor.cursorRight(3); // return "etpractice". current text is "leetpractice". cursor is at index 12. textEditor.cursorLeft(8); // return "leet". current text is "leetpractice". cursor is at index 4. textEditor.deleteText(10); // return 4. current text is "practice". cursor is at index 0. textEditor.cursorLeft(2); // return "". current text is "practice". cursor is at index 0. textEditor.cursorRight(6); // return "practi". current text is "practice". cursor is at index 6.

example_2.py — Empty Text Operations

$ Input: ["TextEditor", "cursorLeft", "cursorRight", "deleteText"] [[], [5], [3], [2]]

› Output: [null, "", "", 0]

💡 Note: All operations on empty text return appropriate default values. Cursor stays at position 0, and deleteText returns 0 since no characters to delete.

example_3.py — Boundary Conditions

$ Input: ["TextEditor", "addText", "cursorLeft", "cursorLeft", "cursorRight", "cursorRight"] [[], ["ab"], [1], [5], [1], [5]]

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

💡 Note: Tests cursor movement beyond text boundaries. cursorLeft(5) moves only 1 position (to beginning), cursorRight(5) moves only 1 position (to end).

Visualization

Tap to expand

Understanding the Visualization

Initialize

Start with two empty stacks representing cursor at beginning

Add Text

Push new characters onto the left stack (before cursor)

Move Cursor

Transfer characters between stacks to simulate cursor movement

Delete Text

Pop characters from left stack (backspace behavior)

Key Takeaway

🎯 Key Insight: Two stacks naturally represent cursor position - left stack = text before cursor, right stack = text after cursor. This makes all text editor operations incredibly efficient!

Time & Space Complexity

Time Complexity

⏱️

O(1)

All operations are O(1) amortized. Stack push/pop operations are O(1), cursor movements transfer characters between stacks in O(k) where k is movement distance

✓ Linear Growth

Space Complexity

O(n)

Two stacks store all n characters of the text

⚡ Linearithmic Space

Constraints

1 ≤ text.length ≤ 50
1 ≤ k ≤ 50
text consists of lowercase English letters.
At most 2 × 10⁴ calls in total will be made to addText, deleteText, cursorLeft and cursorRight.
The sum of all text.length over all addText calls is at most 2 × 10⁴

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28 Apple 22

The optimal solution uses two stacks to represent text before and after the cursor. The left stack contains characters before the cursor (with top being the character just left of cursor), and the right stack contains characters after the cursor. This enables O(1) amortized time complexity for all operations: addText pushes to left stack, deleteText pops from left stack, and cursor movements transfer characters between stacks.

Common Approaches

Approach	Time	Space	Notes
✓ Two Stacks Approach (Optimal)	O(1)	O(n)	Use two stacks to represent text before and after cursor
String Manipulation (Naive)	O(n)	O(n)	Store text as string, rebuild on every operation

Two Stacks Approach (Optimal) — Algorithm Steps

Initialize two stacks: left_stack and right_stack
Left stack top represents character just before cursor
Right stack top represents character just after cursor
addText: push characters to left_stack
deleteText: pop characters from left_stack
cursorLeft: move characters from left_stack to right_stack
cursorRight: move characters from right_stack to left_stack

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Setup

Two empty stacks representing cursor at beginning

Add Text

Push characters to left stack

Cursor Movement

Transfer characters between stacks

Delete Operation

Pop characters from left stack

Code -

solution.c — C

typedef struct {
    char* leftStack;
    char* rightStack;
    int leftSize;
    int rightSize;
    int leftCap;
    int rightCap;
} TextEditor;

TextEditor* textEditorCreate() {
    TextEditor* te = (TextEditor*)malloc(sizeof(TextEditor));
    te->leftStack = (char*)malloc(500000);
    te->rightStack = (char*)malloc(500000);
    te->leftSize = 0;
    te->rightSize = 0;
    te->leftCap = 500000;
    te->rightCap = 500000;
    return te;
}

void textEditorAddText(TextEditor* obj, char* text) {
    int len = strlen(text);
    for (int i = 0; i < len; i++) {
        obj->leftStack[obj->leftSize++] = text[i];
    }
}

int textEditorDeleteText(TextEditor* obj, int k) {
    int deleteCount = (k < obj->leftSize) ? k : obj->leftSize;
    obj->leftSize -= deleteCount;
    return deleteCount;
}

char* textEditorCursorLeft(TextEditor* obj, int k) {
    int moveCount = (k < obj->leftSize) ? k : obj->leftSize;
    for (int i = 0; i < moveCount; i++) {
        obj->rightStack[obj->rightSize++] = obj->leftStack[--obj->leftSize];
    }
    
    char* result = (char*)malloc(11);
    int start = (obj->leftSize > 10) ? obj->leftSize - 10 : 0;
    int len = obj->leftSize - start;
    strncpy(result, obj->leftStack + start, len);
    result[len] = '\0';
    return result;
}

char* textEditorCursorRight(TextEditor* obj, int k) {
    int moveCount = (k < obj->rightSize) ? k : obj->rightSize;
    for (int i = 0; i < moveCount; i++) {
        obj->leftStack[obj->leftSize++] = obj->rightStack[--obj->rightSize];
    }
    
    char* result = (char*)malloc(11);
    int start = (obj->leftSize > 10) ? obj->leftSize - 10 : 0;
    int len = obj->leftSize - start;
    strncpy(result, obj->leftStack + start, len);
    result[len] = '\0';
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

All operations are O(1) amortized. Stack push/pop operations are O(1), cursor movements transfer characters between stacks in O(k) where k is movement distance

✓ Linear Growth

Space Complexity

O(n)

Two stacks store all n characters of the text

⚡ Linearithmic Space

Constraints

1 ≤ text.length ≤ 50
1 ≤ k ≤ 50
text consists of lowercase English letters.
At most 2 × 10⁴ calls in total will be made to addText, deleteText, cursorLeft and cursorRight.
The sum of all text.length over all addText calls is at most 2 × 10⁴

42.3K Views

Medium-High Frequency

~25 min Avg. Time

1.8K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two Stacks Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler