Minimum Length of String After Operations

Minimum Length of String After Operations - Problem

You are given a string s. You can perform the following process on s any number of times:

Choose an index i in the string such that there is at least one character to the left of index i that is equal to s[i], and at least one character to the right that is also equal to s[i].

Delete the closest occurrence of s[i] located to the left of i.

Delete the closest occurrence of s[i] located to the right of i.

Return the minimum length of the final string s that you can achieve.

Input & Output

Example 1 — Basic Case

$ Input: s = "aabcca"

› Output: 4

💡 Note: We can choose index 1 (second 'a'), which has 'a' at position 0 (left) and 'a' at positions 4,5 (closest right is 4). Remove positions 0 and 4, leaving 'abcc' with length 4.

Example 2 — All Different

$ Input: s = "abc"

› Output: 3

💡 Note: All characters appear only once, so no operations possible. Final length equals original length: 3

Example 3 — High Frequency

$ Input: s = "aaaa"

› Output: 2

💡 Note: Character 'a' appears 4 times, but can only contribute 2 to final result. Operations can reduce 4 a's to 2 a's

Constraints

1 ≤ s.length ≤ 2 × 10⁵
s consists of lowercase English letters only

Visualization

Tap to expand

Asked in

G Google 25 f Meta 20 a Amazon 18

The key insight is that each character can appear at most 2 times in the final string. Characters with frequency ≥ 3 can be reduced through removal operations. The frequency counting approach directly calculates the answer by taking min(frequency, 2) for each character. Time: O(n), Space: O(1).

Common Approaches

✓ Frequency Count Optimization

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

Count how many times each character appears. Characters with frequency ≥ 3 can be reduced by removing triplets. Each character can contribute at most 2 to the final length.

Simulation Approach

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

For each position, check if there are matching characters on both sides. If found, remove the closest matches and repeat the process until no more operations can be performed.

Frequency Count Optimization — Algorithm Steps

Count frequency of each character
For each char with freq ≥ 3, reduce to at most 2
Sum remaining characters

Visualization

Tap to expand

Step-by-Step Walkthrough

Count

Count frequency of each character

Analyze

Each character contributes min(frequency, 2)

Sum

Add up contributions for final answer

Code -

solution.c — C

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

int solution(char* s) {
    int len = strlen(s);
    
    while (1) {
        int found = 0;
        
        for (int i = 0; i < len; i++) {
            char ch = s[i];
            
            // Find closest left occurrence
            int leftIdx = -1;
            for (int j = i - 1; j >= 0; j--) {
                if (s[j] == ch) {
                    leftIdx = j;
                    break;
                }
            }
            
            // Find closest right occurrence
            int rightIdx = -1;
            for (int j = i + 1; j < len; j++) {
                if (s[j] == ch) {
                    rightIdx = j;
                    break;
                }
            }
            
            // If both found, perform deletion
            if (leftIdx != -1 && rightIdx != -1) {
                // Remove right first (higher index)
                memmove(s + rightIdx, s + rightIdx + 1, len - rightIdx);
                len--;
                // Remove left (index unchanged after right removal)
                memmove(s + leftIdx, s + leftIdx + 1, len - leftIdx);
                len--;
                found = 1;
                break;
            }
        }
        
        if (!found) break;
    }
    
    return len;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to count frequencies plus O(26) to process character counts

⚠ Quadratic Growth

Space Complexity

O(1)

Hash map stores at most 26 characters for lowercase English letters

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~15 min Avg. Time

890 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

Constraints

Visualization

Related Problems

Common Approaches

Frequency Count Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler