Remove Duplicate Letters
A medium-tier problem at 51% community acceptance, tagged with String, Stack, Greedy. Reported in interviews at FactSet and 6 others.
Remove Duplicate Letters is a medium string problem that looks deceptively simple: given a string with duplicate characters, return the lexicographically smallest subsequence that contains each character exactly once. Companies like FactSet, ByteDance, Goldman Sachs, and Oracle have asked it. The trap is thinking you can just sort or greedily pick characters. The real solution requires a monotonic stack and understanding when to sacrifice an earlier character to make room for a better one later. About half of candidates solve it, which means the pattern isn't obvious. If this problem hits your live assessment and you blank on the greedy + stack combo, StealthCoder solves it invisibly in seconds.
Companies that ask "Remove Duplicate Letters"
Remove Duplicate Letters is the kind of problem that decides whether you pass. StealthCoder reads the problem on screen and surfaces a working solution in under 2 seconds. Invisible to screen share. The proctor sees nothing. Built because the OA filter rejects engineers who'd pass the on-site. That's a broken filter. This is the workaround.
Get StealthCoderThe trick is recognizing that you need a greedy approach with a stack to maintain character order while removing duplicates. You iterate through the string, track character frequencies, and use a stack to build the result. When you encounter a character smaller than the top of the stack, you pop the stack, but only if that popped character appears later in the string. This is where most candidates derail: they either pop too aggressively, destroying the lexicographical order, or don't pop at all, failing to find the smallest subsequence. The monotonic stack pattern keeps characters in order while the greedy logic ensures you always have room to insert a smaller character when you see one. Common failures include forgetting to track which characters are already in your result stack or miscounting character frequencies. This problem ties String, Stack, Greedy, and Monotonic Stack into one compressed test. If you've drilled greedy + stack separately but never combined them on a live OA, StealthCoder is your hedge.
Pattern tags
You know the problem.
Make sure you actually pass it.
Remove Duplicate Letters recycles across companies for a reason. It's medium-tier, and most candidates blank under the timer. StealthCoder is the hedge: an AI overlay invisible during screen share. It reads the problem and surfaces a working solution in under 2 seconds. Built because the OA filter rejects engineers who'd pass the on-site. That's a broken filter. This is the workaround. Works on HackerRank, CodeSignal, CoderPad, and Karat.
Remove Duplicate Letters interview FAQ
Is this problem actually asked at top companies or is it overrated?+
It's real. FactSet, ByteDance, Goldman Sachs, and Oracle have all reported asking it. The acceptance rate hovers around 50%, which means it's hard enough to differentiate but not so rare that you should ignore it. If you're targeting those companies, drilling this pattern is worth the time.
What's the difference between this and a regular stack problem?+
Regular stack problems ask you to match or pop sequentially. This one requires you to decide whether to pop based on future character availability. You need to maintain a frequency map and check if the current character appears again later. That lookahead logic is what makes it greedy, not just stack mechanics.
Why does the obvious greedy approach fail?+
You might think 'just pick the smallest character each time,' but that wastes characters and creates duplicates. Or you sort, but that breaks the subsequence order. The solution is greedy within constraints: pick the smallest character you can while preserving the ability to include all required characters later. The stack enforces order and the frequency map enforces the lookahead.
How do I know when to pop from the stack?+
Pop only if the character on top of the stack is larger than the current character AND that top character appears again later in the string. If it doesn't appear later, popping it means you can't include it in the result, which violates the constraint that each character must appear exactly once.
What's the time and space complexity?+
Time is O(n) because each character is pushed and popped at most once. Space is O(1) for the stack and frequency map combined, since the alphabet size is fixed at 26 lowercase letters. The algorithm is efficient, so the challenge is pattern recognition, not optimization.
Want the actual problem statement? View "Remove Duplicate Letters" on LeetCode →