Minimize String Length - Practice Coding Problems

Minimize String Length - Problem

Minimize String Length

You are given a string s and need to minimize its length using two powerful operations:

Operation 1: Choose any character at position i, then delete the closest duplicate of that character to the left of position i (if it exists).

Operation 2: Choose any character at position i, then delete the closest duplicate of that character to the right of position i (if it exists).

Your goal is to perform these operations as many times as needed to achieve the minimum possible string length.

Example: In string "abbaca", you can eliminate duplicate 'a's and 'b's, leaving only unique characters.

Return the length of the minimized string after performing optimal operations.

Input & Output

example_1.py — Basic Case

$ Input: s = "aaabc"

› Output: 3

💡 Note: We can eliminate duplicate 'a's by choosing any 'a' and removing its closest duplicate. After optimal operations, we're left with one 'a', one 'b', and one 'c', giving us length 3.

example_2.py — Mixed Duplicates

$ Input: s = "abbaca"

› Output: 3

💡 Note: Starting with 'abbaca', we can remove duplicate 'a's and 'b's through strategic operations. The final result contains one copy each of 'a', 'b', and 'c', so the minimum length is 3.

example_3.py — All Same Characters

$ Input: s = "aaaa"

› Output: 1

💡 Note: When all characters are the same, we can eliminate all but one through repeated operations, leaving a string of length 1.

Constraints

1 ≤ s.length ≤ 1000
s consists of lowercase English letters only
The string is guaranteed to be non-empty

Visualization

Tap to expand

Understanding the Visualization

Initial Analysis

Identify all the characters and their frequencies in the string

Elimination Strategy

Realize that any duplicate character can be eliminated through left/right operations

Optimal Insight

The minimum length equals the number of unique characters

Count Unique

Use a hash set to count distinct characters in one pass

Key Takeaway

🎯 Key Insight: No matter the order of operations, we can always eliminate all duplicate characters through strategic left/right deletions, leaving exactly one copy of each unique character.

Asked in

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

The optimal solution uses the key insight that through strategic deletion operations, we can eliminate all duplicate characters, leaving exactly one copy of each unique character. Simply count the unique characters using a hash set in O(n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Simulation	O(n³)	O(n)	Simulate the actual deletion operations repeatedly until no more deletions are possible
One-Pass Hash Set (Optimal)	O(n)	O(min(n, 26))	Count unique characters using a hash set in a single pass

Brute Force Simulation — Algorithm Steps

Convert string to a list for easy manipulation
Repeat until no changes: for each position, check if we can delete a duplicate to left or right
When a duplicate is found, remove it and mark that a change occurred
Continue until no more changes can be made
Return the final length

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial String

Start with the original string and identify duplicate characters

First Pass

Scan each position and remove closest duplicates to left or right

Repeat Process

Continue the process until no more duplicates can be removed

Final Result

Return the length of the final minimized string

Code -

solution.c — C

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

int minimizedStringLength(char* s) {
    int len = strlen(s);
    char* chars = malloc(len + 1);
    strcpy(chars, s);
    int currentLen = len;
    
    int changed = 1;
    while (changed) {
        changed = 0;
        for (int i = 0; i < currentLen; i++) {
            char currentChar = chars[i];
            
            // Try to delete closest duplicate to the left
            for (int j = i - 1; j >= 0; j--) {
                if (chars[j] == currentChar) {
                    // Remove character at position j
                    for (int k = j; k < currentLen - 1; k++) {
                        chars[k] = chars[k + 1];
                    }
                    currentLen--;
                    changed = 1;
                    i--; // Adjust index
                    break;
                }
            }
            
            // If no left duplicate found, try right
            if (!changed) {
                for (int j = i + 1; j < currentLen; j++) {
                    if (chars[j] == currentChar) {
                        // Remove character at position j
                        for (int k = j; k < currentLen - 1; k++) {
                            chars[k] = chars[k + 1];
                        }
                        currentLen--;
                        changed = 1;
                        break;
                    }
                }
            }
        }
    }
    
    free(chars);
    return currentLen;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    // Remove newline and quotes
    s[strcspn(s, "\n")] = 0;
    if (s[0] == '"') {
        int len = strlen(s);
        memmove(s, s + 1, len - 2);
        s[len - 2] = '\0';
    }
    printf("%d\n", minimizedStringLength(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

In worst case, we might need O(n) iterations, each taking O(n²) time to find and remove duplicates

⚠ Quadratic Growth

Space Complexity

O(n)

We need to store the string as a mutable list for deletions

⚡ Linearithmic Space

24.3K Views

Medium Frequency

~8 min Avg. Time

892 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

Brute Force Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler