Remove Duplicate Letters - Practice Coding Problems

Remove Duplicate Letters - Problem

You're given a string containing lowercase letters, and your mission is to create the lexicographically smallest string possible while ensuring each letter appears exactly once.

This is a classic greedy problem that requires strategic thinking! You need to remove duplicate letters, but not just any removal will do - you must produce the smallest possible result when compared alphabetically.

Example: Given "bcabc", you could form "bca", "cab", or "abc" - but "abc" is lexicographically smallest!

Think of it like arranging books on a shelf - you want the alphabetically earliest arrangement possible using each book exactly once.

Input & Output

example_1.py — Basic Case

$ Input: s = "bcabc"

› Output: "abc"

💡 Note: We have letters 'b', 'c', and 'a'. Since 'a' comes first alphabetically, we want it first. We can form 'abc' by taking the first 'b', first 'c', then 'a', then we need 'b' and 'c' again - but we can get them from the remaining characters.

example_2.py — Different Order

$ Input: s = "cbacdcbc"

› Output: "acdb"

💡 Note: We have letters 'c', 'b', 'a', 'd'. The lexicographically smallest arrangement is 'acdb'. We need to be strategic about which occurrences of each character to keep.

example_3.py — Single Character

$ Input: s = "ecbacba"

› Output: "eacb"

💡 Note: With characters 'e', 'c', 'b', 'a', the optimal arrangement starts with 'e' (appears only once), then 'a' (earliest alphabetically), followed by 'c' and 'b'.

Constraints

1 ≤ s.length ≤ 10⁴
s consists of lowercase English letters
Each character must appear exactly once in the result

Visualization

Tap to expand

Understanding the Visualization

Count Inventory

First, count how many copies of each book (character) you'll receive total

Process Books

As each book arrives, decide if you should replace books already on shelf

Smart Replacement

Remove a book from shelf only if: (1) new book comes alphabetically earlier, (2) you'll get the removed book again later

Final Arrangement

The stack naturally maintains the lexicographically smallest arrangement

Key Takeaway

🎯 Key Insight: The monotonic stack approach works because we can "undo" decisions when we encounter a character that should come earlier, as long as we know that character will appear again later in the string.

Asked in

G Google 45 a Amazon 38 f Facebook 32 ⊞ Microsoft 28

The optimal solution uses a monotonic stack combined with frequency counting. We maintain a stack of characters in our result and greedily remove characters when we find a smaller character that appears later in the string. This ensures we get the lexicographically smallest result while maintaining the uniqueness constraint. Time complexity: O(n), Space complexity: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Possibilities)	O(2^n)	O(2^n)	Generate all possible subsequences with unique characters and find the lexicographically smallest
Monotonic Stack (Optimal)	O(n)	O(1)	Use stack with character frequency counting and greedy removal strategy

Brute Force (Generate All Possibilities) — Algorithm Steps

Generate all possible subsequences of the string
Filter subsequences that contain each character exactly once
Among valid subsequences, find the lexicographically smallest
Return the result

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All

Create all possible subsequences by including/excluding each character

Filter Valid

Keep only subsequences with each unique character exactly once

Find Minimum

Select lexicographically smallest from valid options

Code -

solution.c — C

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

void generateSubsequences(char* s, int index, char* current, int currLen, char results[][100], int* count) {
    if (index == strlen(s)) {
        current[currLen] = '\0';
        strcpy(results[*count], current);
        (*count)++;
        return;
    }
    
    current[currLen] = s[index];
    generateSubsequences(s, index + 1, current, currLen + 1, results, count);
    generateSubsequences(s, index + 1, current, currLen, results, count);
}

int isValid(char* subseq, char* original) {
    int originalCount[26] = {0};
    int subseqCount[26] = {0};
    
    for (int i = 0; i < strlen(original); i++) {
        originalCount[original[i] - 'a'] = 1;
    }
    
    for (int i = 0; i < strlen(subseq); i++) {
        subseqCount[subseq[i] - 'a']++;
    }
    
    for (int i = 0; i < 26; i++) {
        if (originalCount[i] != (subseqCount[i] > 0 ? 1 : 0) || subseqCount[i] > 1) {
            return 0;
        }
    }
    return 1;
}

char* removeDuplicateLetters(char* s) {
    char results[10000][100];
    int count = 0;
    char current[100];
    
    generateSubsequences(s, 0, current, 0, results, &count);
    
    char* result = malloc(100);
    result[0] = '\0';
    int found = 0;
    
    for (int i = 0; i < count; i++) {
        if (isValid(results[i], s)) {
            if (!found || strcmp(results[i], result) < 0) {
                strcpy(result, results[i]);
                found = 1;
            }
        }
    }
    return result;
}

int main() {
    char s[1000];
    fgets(s, sizeof(s), stdin);
    
    // Remove quotes and newline
    char* start = strchr(s, '"');
    if (start) {
        start++;
        char* end = strrchr(start, '"');
        if (end) *end = '\0';
        printf("\"%s\"", removeDuplicateLetters(start));
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

We generate all 2^n possible subsequences, where n is the string length

⚠ Quadratic Growth

Space Complexity

O(2^n)

Need to store all possible subsequences in memory

⚠ Quadratic Space

34.4K Views

High Frequency

~25 min Avg. Time

1.5K 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 (Generate All Possibilities) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler