Design a Text Editor

Design a Text Editor - Problem

Linked List String Stack Design Simulation Doubly-Linked List Hard

Design a text editor with a cursor that can perform the following operations:

Add text to where the cursor is positioned
Delete text from where the cursor is (simulating the backspace key)
Move the cursor either left or right

When deleting text, only characters to the left of the cursor will be deleted. The cursor will always remain within the actual text boundaries: 0 ≤ cursor.position ≤ currentText.length.

Implement the TextEditor class with these methods:

TextEditor() - Initializes the object with empty text
void addText(string text) - Appends text at cursor position, cursor moves to right of added text
int deleteText(int k) - Deletes k characters to the left of cursor, returns actual number of characters deleted
string cursorLeft(int k) - Moves cursor left k times, returns last min(10, len) characters to the left of cursor
string cursorRight(int k) - Moves cursor right k times, returns last min(10, len) characters to the left of cursor

Input & Output

Example 1 — Basic Operations

$ Input: operations = [["TextEditor"],["addText","leetcode"],["deleteText",4],["addText","practice"],["cursorRight",3],["cursorLeft",8]]

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

💡 Note: TextEditor textEditor = new TextEditor(); // Initially text="", cursor=0 textEditor.addText("leetcode"); // text="leetcode", cursor=8 textEditor.deleteText(4); // return 4, text="leet", cursor=4 textEditor.addText("practice"); // text="leetpractice", cursor=12 textEditor.cursorRight(3); // return "etpractice" (cursor at end, last 10 chars) textEditor.cursorLeft(8); // return "leet" (cursor at pos 4, 4 chars to left)

Example 2 — Cursor Movements

$ Input: operations = [["TextEditor"],["addText","hello"],["cursorLeft",3],["addText","world"],["cursorRight",2]]

› Output: [null,null,"he",null,"heworldl"]

💡 Note: Start empty, add "hello" (cursor at end), move left 3 positions (cursor after 'e'), add "world", move right 2 positions. Final text: "heworldllo"

Example 3 — Edge Case Boundaries

$ Input: operations = [["TextEditor"],["cursorLeft",5],["addText","a"],["deleteText",10],["cursorRight",5]]

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

💡 Note: Try to move left from empty (returns ""), add 'a', try to delete 10 chars (only deletes 1), try to move right from empty (returns "")

Constraints

1 ≤ text.length, k ≤ 40
text consists of lowercase English letters
At most 2 × 10⁴ calls in total will be made to addText, deleteText, cursorLeft and cursorRight

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 20 A Amazon 18 F Meta 15

Design a text editor using two stacks to efficiently handle cursor operations. The key insight is representing the cursor as the boundary between left and right stacks. Best approach achieves O(1) time for all operations. Time: O(1) per operation, Space: O(n) for text storage.

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Hash Map

⏱️ Time: N/A Space: N/A

Single String with Rebuilding

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

Maintain the entire text as one string with cursor position. For each operation, manipulate the string by slicing and concatenating parts.

Two Stacks Approach

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

Maintain two stacks: left stack contains characters before cursor (top = character just left of cursor), right stack contains characters after cursor. Cursor operations become simple stack operations.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

typedef struct {
    int* queue;
    int front;
    int rear;
    int capacity;
    int size;
} HitCounter;

HitCounter* hitCounterCreate() {
    HitCounter* counter = malloc(sizeof(HitCounter));
    counter->queue = malloc(10000 * sizeof(int));
    counter->front = 0;
    counter->rear = 0;
    counter->capacity = 10000;
    counter->size = 0;
    return counter;
}

void hitCounterHit(HitCounter* obj, int timestamp) {
    obj->queue[obj->rear] = timestamp;
    obj->rear = (obj->rear + 1) % obj->capacity;
    obj->size++;
}

int hitCounterGetHits(HitCounter* obj, int timestamp) {
    // Remove expired hits
    while (obj->size > 0 && obj->queue[obj->front] <= timestamp - 300) {
        obj->front = (obj->front + 1) % obj->capacity;
        obj->size--;
    }
    return obj->size;
}

char* trim(char* str) {
    while (isspace(*str)) str++;
    char* end = str + strlen(str) - 1;
    while (end > str && isspace(*end)) end--;
    *(end + 1) = 0;
    return str;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line1[10000], line2[10000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    // Remove newlines
    line1[strcspn(line1, "\n")] = 0;
    line2[strcspn(line2, "\n")] = 0;
    
    HitCounter* counter = hitCounterCreate();
    
    // Simple parsing for operations and values
    char operations[100][20];
    int values[100][10];
    int op_count = 0;
    
    // Parse operations (simplified)
    char* ops = line1 + 1; // skip [
    ops[strlen(ops) - 1] = 0; // remove ]
    
    char* token = strtok(ops, ",");
    while (token && op_count < 100) {
        token = trim(token);
        if (token[0] == '"') {
            strcpy(operations[op_count], token + 1);
            operations[op_count][strlen(operations[op_count]) - 1] = 0; // remove quote
        } else {
            strcpy(operations[op_count], token);
        }
        op_count++;
        token = strtok(NULL, ",");
    }
    
    // Parse values (simplified)
    char* vals = line2 + 1; // skip [
    vals[strlen(vals) - 1] = 0; // remove ]
    
    int val_count = 0;
    char* bracket_start = vals;
    while (*bracket_start && val_count < op_count) {
        if (*bracket_start == '[') {
            bracket_start++;
            char* bracket_end = strchr(bracket_start, ']');
            if (bracket_end) {
                *bracket_end = 0;
                if (strlen(bracket_start) > 0) {
                    values[val_count][0] = atoi(trim(bracket_start));
                }
                bracket_start = bracket_end + 1;
                while (*bracket_start == ',' || *bracket_start == ' ') bracket_start++;
            }
        } else {
            bracket_start++;
        }
        val_count++;
    }
    
    // Execute operations
    printf("[null");
    for (int i = 1; i < op_count; i++) {
        if (strcmp(operations[i], "hit") == 0) {
            hitCounterHit(counter, values[i][0]);
            printf(",null");
        } else if (strcmp(operations[i], "getHits") == 0) {
            int result = hitCounterGetHits(counter, values[i][0]);
            printf(",%d", result);
        }
    }
    printf("]\n");
    
    free(counter->queue);
    free(counter);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

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