Design a Text Editor

Problem

Design a text editor with a cursor that can do the following:

Add text to where the cursor is.
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 also remain within the actual text and cannot be moved beyond it. More formally, we have that 0 <= cursor.position <= currentText.length always holds.

Implement the TextEditor class:

TextEditor() Initializes the object with empty text.
void addText(string text) Appends text to where the cursor is. The cursor ends to the right of text.
int deleteText(int k) Deletes k characters to the left of the cursor. Returns the number of characters actually deleted.
string cursorLeft(int k) Moves the cursor to the left k times. Returns the last min(10, len) characters to the left of the cursor, where len is the number of characters to the left of the cursor.
string cursorRight(int k) Moves the cursor to the right k times. Returns the last min(10, len) characters to the left of the cursor, where len is the number of characters to the left of the cursor.

Examples

Example 1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


**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"]

**Explanation**
TextEditor textEditor = new TextEditor(); // The current text is "|". (The '|' character represents the cursor)
textEditor.addText("leetcode"); // The current text is "leetcode|".
textEditor.deleteText(4); // return 4
                          // The current text is "leet|". 
                          // 4 characters were deleted.
textEditor.addText("practice"); // The current text is "leetpractice|". 
textEditor.cursorRight(3); // return "etpractice"
                           // The current text is "leetpractice|". 
                           // The cursor cannot be moved beyond the actual text and thus did not move.
                           // "etpractice" is the last 10 characters to the left of the cursor.
textEditor.cursorLeft(8); // return "leet"
                          // The current text is "leet|practice".
                          // "leet" is the last min(10, 4) = 4 characters to the left of the cursor.
textEditor.deleteText(10); // return 4
                           // The current text is "|practice".
                           // Only 4 characters were deleted.
textEditor.cursorLeft(2); // return ""
                          // The current text is "|practice".
                          // The cursor cannot be moved beyond the actual text and thus did not move. 
                          // "" is the last min(10, 0) = 0 characters to the left of the cursor.
textEditor.cursorRight(6); // return "practi"
                           // The current text is "practi|ce".
                           // "practi" is the last min(10, 6) = 6 characters to the left of the cursor.

Constraints

1 <= text.length, k <= 40
text consists of lowercase English letters.
At most 2 * 10^4 calls in total will be made to addText, deleteText, cursorLeft and cursorRight.

Follow-up: Could you find a solution with time complexity of O(k) per call?

Solution

Method 1 – Two Stacks for Efficient Cursor and Text Operations

Intuition

To efficiently support cursor movement, text addition, and deletion, we can use two stacks: one for the text to the left of the cursor and one for the text to the right. This allows all operations to be performed in O(1) or O(k) time, where k is the number of characters moved or deleted.

Approach

Use two stacks: left for characters to the left of the cursor, and right for characters to the right.
addText(text): Push each character of text onto the left stack.
deleteText(k): Pop up to k characters from the left stack and return the number of characters actually deleted.
cursorLeft(k): Move up to k characters from left to right stack. Return the last up to 10 characters from the left stack as a string.
cursorRight(k): Move up to k characters from right to left stack. Return the last up to 10 characters from the left stack as a string.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


class TextEditor:
    def __init__(self):
        self.left = []  # stack for text to the left of cursor
        self.right = []  # stack for text to the right of cursor
    def addText(self, text: str) -> None:
        for c in text:
            self.left.append(c)
    def deleteText(self, k: int) -> int:
        cnt = 0
        while self.left and cnt < k:
            self.left.pop()
            cnt += 1
        return cnt
    def cursorLeft(self, k: int) -> str:
        for _ in range(min(k, len(self.left))):
            self.right.append(self.left.pop())
        return ''.join(self.left[-10:])
    def cursorRight(self, k: int) -> str:
        for _ in range(min(k, len(self.right))):
            self.left.append(self.right.pop())
        return ''.join(self.left[-10:])

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45


#include <stack>
#include <string>
using namespace std;
class TextEditor {
    stack<char> left, right;
public:
    TextEditor() {}
    void addText(string text) {
        for (char c : text) left.push(c);
    }
    int deleteText(int k) {
        int cnt = 0;
        while (!left.empty() && cnt < k) {
            left.pop();
            cnt++;
        }
        return cnt;
    }
    string cursorLeft(int k) {
        while (!left.empty() && k--) {
            right.push(left.top());
            left.pop();
        }
        string ans;
        stack<char> tmp = left;
        while (!tmp.empty() && ans.size() < 10) {
            ans = tmp.top() + ans;
            tmp.pop();
        }
        return ans;
    }
    string cursorRight(int k) {
        while (!right.empty() && k--) {
            left.push(right.top());
            right.pop();
        }
        string ans;
        stack<char> tmp = left;
        while (!tmp.empty() && ans.size() < 10) {
            ans = tmp.top() + ans;
            tmp.pop();
        }
        return ans;
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


import java.util.*;
public class TextEditor {
    Deque<Character> left = new ArrayDeque<>();
    Deque<Character> right = new ArrayDeque<>();
    public TextEditor() {}
    public void addText(String text) {
        for (char c : text.toCharArray()) left.addLast(c);
    }
    public int deleteText(int k) {
        int cnt = 0;
        while (!left.isEmpty() && cnt < k) {
            left.removeLast();
            cnt++;
        }
        return cnt;
    }
    public String cursorLeft(int k) {
        while (!left.isEmpty() && k-- > 0) right.addFirst(left.removeLast());
        StringBuilder sb = new StringBuilder();
        Iterator<Character> it = left.descendingIterator();
        int cnt = 0;
        while (it.hasNext() && cnt < 10) {
            sb.append(it.next());
            cnt++;
        }
        return sb.reverse().toString();
    }
    public String cursorRight(int k) {
        while (!right.isEmpty() && k-- > 0) left.addLast(right.removeFirst());
        StringBuilder sb = new StringBuilder();
        Iterator<Character> it = left.descendingIterator();
        int cnt = 0;
        while (it.hasNext() && cnt < 10) {
            sb.append(it.next());
            cnt++;
        }
        return sb.reverse().toString();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


type TextEditor struct {
    left, right []byte
}
func Constructor() TextEditor {
    return TextEditor{[]byte{}, []byte{}}
}
func (te *TextEditor) AddText(text string) {
    te.left = append(te.left, text...)
}
func (te *TextEditor) DeleteText(k int) int {
    cnt := 0
    for len(te.left) > 0 && cnt < k {
        te.left = te.left[:len(te.left)-1]
        cnt++
    }
    return cnt
}
func (te *TextEditor) CursorLeft(k int) string {
    for i := 0; i < k && len(te.left) > 0; i++ {
        te.right = append(te.right, te.left[len(te.left)-1])
        te.left = te.left[:len(te.left)-1]
    }
    l := len(te.left)
    if l > 10 {
        return string(te.left[l-10:])
    }
    return string(te.left)
}
func (te *TextEditor) CursorRight(k int) string {
    for i := 0; i < k && len(te.right) > 0; i++ {
        te.left = append(te.left, te.right[len(te.right)-1])
        te.right = te.right[:len(te.right)-1]
    }
    l := len(te.left)
    if l > 10 {
        return string(te.left[l-10:])
    }
    return string(te.left)
}

Complexity

⏰ Time complexity: O(k) per operation, where k is the number of characters moved or deleted.
🧺 Space complexity: O(n), where n is the total number of characters in the editor.

Problem#

Examples#

Example 1#

Constraints#

Solution#

Method 1 – Two Stacks for Efficient Cursor and Text Operations#

Intuition#

Approach#

Code#

Complexity#