Longest Common Prefix After at Most One Removal

Longest Common Prefix After at Most One Removal - Problem

Imagine you have two strings s and t, and you want to find the longest common prefix they can share. The twist? You're allowed to remove at most one character from string s to maximize this common prefix length.

A common prefix is a sequence of characters that appears at the beginning of both strings. For example, "abc" is a common prefix of "abcdef" and "abcxyz".

Your task: Return the length of the longest possible common prefix between s and t after removing at most one character from s. Remember, you can also choose to remove no characters at all if that gives the best result!

Example: If s = "abcdef" and t = "acdef", removing the 'b' from s gives us "acdef", which has a common prefix "acdef" with t, resulting in length 5.

Input & Output

example_1.py — Basic Case

$ Input: s = "abcdef"\nt = "acdef"

› Output: 5

💡 Note: Removing 'b' from s gives "acdef", which has a common prefix "acdef" with t, length 5

example_2.py — No Removal Needed

$ Input: s = "hello"\nt = "help"

› Output: 3

💡 Note: Without removal, common prefix is "hel" with length 3. Removing any character doesn't improve this.

example_3.py — Empty Result

$ Input: s = "xyz"\nt = "abc"

› Output: 0

💡 Note: No common prefix possible even with removal, so result is 0

Visualization

Tap to expand

Understanding the Visualization

Find the Mismatch

Compare characters from left to right until they differ

Record Current Progress

Note the common prefix length found so far

Try Smart Removals

Remove the mismatched character or the one before it

Choose the Best

Return the maximum length among all attempts

Key Takeaway

🎯 Key Insight: Instead of trying all possible removals, we only need to strategically try removing characters at or near the first mismatch point, reducing time complexity from O(n²) to O(n).

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through both strings to find mismatch, then at most two additional prefix calculations

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables, no additional strings created

✓ Linear Space

Constraints

1 ≤ s.length, t.length ≤ 10⁵
s and t consist of lowercase English letters only
At most one character can be removed from s

Asked in

G Google 15 ⊞ Microsoft 12 a Amazon 8 f Meta 5

The optimal solution uses two pointers to efficiently find where the strings first differ, then tries at most two strategic character removals. This achieves O(n) time complexity compared to the brute force O(n²) approach that tries all possible removals.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Optimal)	O(n)	O(1)	Use two pointers to efficiently find the optimal removal position
Brute Force (Try All Removals)	O(n²)	O(n)	Try removing each character from s and find the longest common prefix

Two Pointers (Optimal) — Algorithm Steps

Use two pointers to find the first mismatch position between s and t
Calculate the common prefix length without removal
Try removing the mismatched character from s and calculate new common prefix
Also try removing the character before the mismatch if it exists
Return the maximum length found

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Mismatch

Use two pointers to find where strings first differ

Record Initial Length

Common prefix length up to mismatch point

Try Skip Mismatch

Skip the mismatching character and continue comparison

Try Skip Previous

Sometimes skipping previous character yields better result

Code -

solution.c — C

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

int getCommonPrefixLength(const char* s1, const char* s2, int skipS) {
    int i = 0, j = 0;
    while (s1[i] && s2[j]) {
        if (i == skipS) {
            i++;
            continue;
        }
        if (s1[i] != s2[j]) {
            break;
        }
        i++;
        j++;
    }
    return j;
}

int longestCommonPrefix(char* s, char* t) {
    int sLen = strlen(s);
    int tLen = strlen(t);
    
    // Find first mismatch position
    int mismatch = 0;
    while (mismatch < sLen && mismatch < tLen && s[mismatch] == t[mismatch]) {
        mismatch++;
    }
    
    // Case 1: No removal needed
    int maxLen = mismatch;
    
    // Case 2: Remove character at mismatch position from s
    if (mismatch < sLen) {
        int newLen = getCommonPrefixLength(s, t, mismatch);
        if (newLen > maxLen) maxLen = newLen;
    }
    
    // Case 3: Try removing character before mismatch
    if (mismatch > 0) {
        int newLen = getCommonPrefixLength(s, t, mismatch - 1);
        if (newLen > maxLen) maxLen = newLen;
    }
    
    return maxLen;
}

int main() {
    char s[1001], t[1001];
    fgets(s, sizeof(s), stdin);
    fgets(t, sizeof(t), stdin);
    
    // Remove newlines
    s[strcspn(s, "\n")] = 0;
    t[strcspn(t, "\n")] = 0;
    
    printf("%d\n", longestCommonPrefix(s, t));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through both strings to find mismatch, then at most two additional prefix calculations

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables, no additional strings created

✓ Linear Space

Constraints

1 ≤ s.length, t.length ≤ 10⁵
s and t consist of lowercase English letters only
At most one character can be removed from s

18.0K Views

Medium Frequency

~15 min Avg. Time

450 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