Codestin Search App

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
✓ Monotonic Stack (Optimal)	O(n)	O(1)	Use stack with character frequency counting and greedy removal strategy
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) — Algorithm Steps

Count frequency of each character in the string
Use a stack to build result and a set to track included characters
For each character, decrement its frequency
If character is already in result, skip it
While stack top is greater than current char AND appears later, pop it
Add current character to stack and mark as included

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

First pass: count how many times each character appears

Process Characters

For each character, decide whether to keep previous characters

Greedy Removal

Remove larger characters if they appear later in string

Build Result

Stack contents form the lexicographically smallest result

Code -

solution.c — C

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

char* removeDuplicateLetters(char* s) {
    int len = strlen(s);
    
    // Count frequency of each character
    int count[26] = {0};
    for (int i = 0; i < len; i++) {
        count[s[i] - 'a']++;
    }
    
    // Stack to build result, boolean array to track what's in result
    char* stack = (char*)malloc((len + 1) * sizeof(char));
    int stackSize = 0;
    bool inStack[26] = {false};
    
    for (int i = 0; i < len; i++) {
        char c = s[i];
        
        // Decrement count as we process each character
        count[c - 'a']--;
        
        // If already in result, skip
        if (inStack[c - 'a']) {
            continue;
        }
        
        // Remove characters from stack that are:
        // 1. Greater than current character (lexicographically)
        // 2. Appear later in the string (count > 0)
        while (stackSize > 0 && stack[stackSize - 1] > c && 
               count[stack[stackSize - 1] - 'a'] > 0) {
            char removed = stack[stackSize - 1];
            stackSize--;
            inStack[removed - 'a'] = false;
        }
        
        // Add current character
        stack[stackSize] = c;
        stackSize++;
        inStack[c - 'a'] = true;
    }
    
    stack[stackSize] = '\0';
    return stack;
}

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';
        char* result = removeDuplicateLetters(start);
        printf("\"%s\"", result);
        free(result);
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through string, each character pushed and popped at most once

✓ Linear Growth

Space Complexity

O(1)

Only need arrays for 26 lowercase letters plus result stack

✓ Linear 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

Monotonic Stack (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler