Backspace String Compare - Practice Coding Problems

Backspace String Compare - Problem

Imagine you're typing on two different text editors with a special backspace key represented by the '#' character. Your task is to determine if both editors will display the same final text after processing all the keystrokes.

The Challenge: Given two strings s and t, return true if they are equal when both are typed into empty text editors. The '#' character means backspace - it removes the previous character (if any exists). If you backspace on an empty text editor, it remains empty.

Example: "ab#c" becomes "ac" (type 'a', type 'b', backspace removes 'b', type 'c')

Input & Output

example_1.py — Basic backspace operations

$ Input: s = "ab#c", t = "ad#c"

› Output: true

💡 Note: Both strings become "ac" after processing backspaces: s: type 'a', type 'b', backspace (remove 'b'), type 'c' → "ac". t: type 'a', type 'd', backspace (remove 'd'), type 'c' → "ac".

example_2.py — Multiple backspaces

$ Input: s = "ab##", t = "c#d#"

› Output: true

💡 Note: Both strings become empty after processing: s: type 'a', type 'b', backspace twice (remove 'b', then 'a') → "". t: type 'c', backspace (remove 'c'), type 'd', backspace (remove 'd') → "".

example_3.py — Backspace on empty string

$ Input: s = "a#c", t = "b"

› Output: false

💡 Note: s becomes "c" (type 'a', backspace, type 'c'), while t remains "b". Since "c" ≠ "b", the result is false.

Visualization

Tap to expand

Understanding the Visualization

Start Typing

Both users begin typing their respective strings character by character

Handle Backspaces

When '#' is encountered, the previous character is deleted from the display

Compare Results

After processing all keystrokes, compare the final text on both screens

Key Takeaway

🎯 Key Insight: Working backwards eliminates the need to build complete strings - we can directly compare the final valid characters while efficiently handling backspaces.

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Single pass through both strings where n and m are string lengths

✓ Linear Growth

Space Complexity

O(1)

Only uses a few variables for pointers and backspace counting

✓ Linear Space

Constraints

1 ≤ s.length, t.length ≤ 200
s and t only contain lowercase letters and '#' characters
Follow up: Can you solve it in O(n) time and O(1) space?

Asked in

G Google 28 f Facebook 15 Apple 12 ⊞ Microsoft 8

The optimal solution uses two pointers working backwards through both strings. By processing from right to left, we can efficiently handle backspaces and compare only the characters that would remain in the final text, achieving O(1) space complexity without building intermediate strings.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Optimal)	O(n + m)	O(1)	Compare characters by working backwards through both strings simultaneously
Stack Simulation	O(n + m)	O(n + m)	Simulate typing for both strings using stacks, then compare final results

Two Pointers (Optimal) — Algorithm Steps

Initialize pointers at the end of both strings
For each string, move pointer backwards while counting and skipping backspaces
Find the next valid character in each string
Compare the valid characters - if different, return false
Continue until both strings are fully processed

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at End

Initialize pointers at the end of both strings

Skip Backspaces

Count and skip characters that would be deleted by '#'

Compare Valid

Compare the next valid characters from both strings

Continue

Move pointers backwards and repeat until done

Code -

solution.c — C

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

int getNextValidIndex(char* str, int index) {
    int backspaceCount = 0;
    while (index >= 0) {
        if (str[index] == '#') {
            backspaceCount++;
        } else if (backspaceCount > 0) {
            backspaceCount--;
        } else {
            return index;
        }
        index--;
    }
    return -1;
}

int backspaceCompare(char* s, char* t) {
    int i = strlen(s) - 1;
    int j = strlen(t) - 1;
    
    while (i >= 0 || j >= 0) {
        i = getNextValidIndex(s, i);
        j = getNextValidIndex(t, j);
        
        char charS = i >= 0 ? s[i] : 0;
        char charT = j >= 0 ? t[j] : 0;
        
        if (charS != charT) {
            return 0;
        }
        
        if (i >= 0) i--;
        if (j >= 0) j--;
    }
    
    return 1;
}

int main() {
    char s[1000], t[1000];
    scanf("%s %s", s, t);
    printf("%s\n", backspaceCompare(s, t) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Single pass through both strings where n and m are string lengths

✓ Linear Growth

Space Complexity

O(1)

Only uses a few variables for pointers and backspace counting

✓ Linear Space

Constraints

1 ≤ s.length, t.length ≤ 200
s and t only contain lowercase letters and '#' characters
Follow up: Can you solve it in O(n) time and O(1) space?

89.6K Views

Medium Frequency

~15 min Avg. Time

2.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 Pointers (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler