Minimum Length of String After Deleting Similar Ends - Problem

Given a string s consisting only of characters 'a', 'b', and 'c'. You are asked to apply the following algorithm on the string any number of times:

Pick a non-empty prefix from the string s where all the characters in the prefix are equal.
Pick a non-empty suffix from the string s where all the characters in this suffix are equal.
The prefix and the suffix should not intersect at any index.
The characters from the prefix and suffix must be the same.
Delete both the prefix and suffix.

Return the minimum length of s after performing the above operation any number of times (possibly zero times).

Input & Output

Example 1 — Basic Removal

$ Input: s = "caabbc"

› Output: 0

💡 Note: Remove prefix "c" and suffix "c" → "aabb". Then remove prefix "aa" and suffix "bb" → "". Final length is 0.

Example 2 — Partial Removal

$ Input: s = "aabccabba"

› Output: 3

💡 Note: Remove prefix "aa" and suffix "a" → "bccabb". Remove prefix "b" and suffix "bb" → "cca". No more removals possible. Final length is 3.

Example 3 — No Removal

$ Input: s = "abc"

› Output: 3

💡 Note: No matching prefix-suffix pairs exist (a ≠ c, b can't form both prefix and suffix without overlap). Final length is 3.

Constraints

1 ≤ s.length ≤ 10⁵
s consists only of characters 'a', 'b', and 'c'

Visualization

Tap to expand

Asked in

f Facebook 25 a Amazon 20 G Google 18

The key insight is to greedily remove the longest possible matching prefix-suffix pairs using two pointers. Best approach uses two pointers moving inward to efficiently identify and remove character layers. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force - Try All Combinations

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

For each possible prefix length and suffix length, check if characters match and don't overlap, then recursively solve for the remaining string. This explores all possible deletion sequences.

Two Pointers - Greedy Approach

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

Use left and right pointers to identify matching characters at both ends. Greedily extend the longest possible matching prefix and suffix, then remove them and repeat until no more removals are possible.

Brute Force - Try All Combinations — Algorithm Steps

Try all possible prefix lengths from 1 to n/2
For each prefix, try all valid suffix lengths
Recursively solve for remaining string after deletion
Return minimum length across all possibilities

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Prefix Length 1

Check all valid suffix combinations

Try Prefix Length 2

Check all valid suffix combinations

Continue Recursively

Solve remaining string after each deletion

Code -

solution.c — C

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

int solve(char* s) {
    int n = strlen(s);
    if (n == 0) return 0;
    
    int minLen = n; // No deletion case
    
    // Try all possible prefix-suffix pairs
    for (int prefixLen = 1; prefixLen <= n / 2; prefixLen++) {
        char prefixChar = s[0];
        // Check if prefix has all same characters
        int validPrefix = 1;
        for (int i = 0; i < prefixLen; i++) {
            if (s[i] != prefixChar) {
                validPrefix = 0;
                break;
            }
        }
        
        if (validPrefix) {
            for (int suffixLen = 1; suffixLen <= n - prefixLen; suffixLen++) {
                char suffixChar = s[n - 1];
                // Check if suffix has all same characters and matches prefix
                if (suffixChar == prefixChar) {
                    int validSuffix = 1;
                    for (int i = 0; i < suffixLen; i++) {
                        if (s[n - 1 - i] != suffixChar) {
                            validSuffix = 0;
                            break;
                        }
                    }
                    
                    if (validSuffix) {
                        char remaining[1001];
                        strncpy(remaining, s + prefixLen, n - prefixLen - suffixLen);
                        remaining[n - prefixLen - suffixLen] = '\0';
                        int result = solve(remaining);
                        if (result < minLen) {
                            minLen = result;
                        }
                    }
                }
            }
        }
    }
    
    return minLen;
}

int solution(char* s) {
    return solve(s);
}

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

Time & Space Complexity

Time Complexity

⏱️

O(3ⁿ)

Each position can be part of prefix, suffix, or remaining string, leading to exponential combinations

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth can go up to n levels in worst case

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~15 min Avg. Time

891 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

Minimum Length of String After Deleting Similar Ends - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler