Remove K Digits - Practice Coding Problems

Remove K Digits - Problem

Given a string num representing a non-negative integer and an integer k, your task is to remove exactly k digits from the number to create the smallest possible integer.

The goal is to strategically remove digits to minimize the resulting number. For example, from "1432219" removing 3 digits, we want to get "1219" (not "4329" or "1432").

Key Points:

You must remove exactly k digits
The result should be the smallest possible number
Leading zeros should be removed from the final result
If all digits are removed, return "0"

Input & Output

example_1.py — Basic Case

$ Input: num = "1432219", k = 3

› Output: "1219"

💡 Note: Remove digits '4', '3', and '2' (the first '2') to get the smallest result. The optimal strategy is to remove larger digits that appear before smaller ones.

example_2.py — All Same Digits

$ Input: num = "10200", k = 1

› Output: "200"

💡 Note: Remove the leading '1' to get the smallest possible number. Since we want the smallest result, we remove the leftmost non-zero digit.

example_3.py — Remove All Digits

$ Input: num = "9", k = 1

› Output: "0"

💡 Note: When all digits are removed, return "0" as specified in the problem statement.

Visualization

Tap to expand

Understanding the Visualization

Scan Left to Right

Process each digit from left to right, as position matters for final value

Greedy Removal

When you see a smaller digit, remove any larger digits before it (while you have removals left)

Maintain Stack

Keep a stack of digits in non-decreasing order to build the optimal result

Handle Edge Cases

Remove from end if needed, clean leading zeros, return '0' if empty

Key Takeaway

🎯 Key Insight: The monotonic stack approach greedily removes larger digits when smaller ones appear later, ensuring we get the lexicographically smallest result in optimal O(n) time.

Time & Space Complexity

Time Complexity

⏱️

O(n)

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

✓ Linear Growth

Space Complexity

O(n)

Stack space for storing the result digits

⚡ Linearithmic Space

Constraints

1 ≤ num.length ≤ 10⁴
0 ≤ k ≤ num.length
num consists of only digits
num does not have any leading zeros except for the zero itself

Asked in

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

The optimal solution uses a monotonic stack with a greedy approach. The key insight is to maintain a non-decreasing sequence by removing larger digits that appear before smaller ones. This achieves O(n) time complexity in a single pass through the input string.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(C(n,k) * n)	O(n)	Generate all possible combinations of removing k digits and find the minimum
Monotonic Stack (Optimal)	O(n)	O(n)	Use a greedy approach with stack to maintain monotonic increasing sequence

Brute Force (Try All Combinations) — Algorithm Steps

Generate all combinations of k positions to remove from the string
For each combination, create a new number by removing those digits
Remove leading zeros from each resulting number
Compare all results and return the smallest number
Handle edge case where result is empty (return "0")

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Create all possible ways to select k positions to remove

Build Results

For each combination, build the resulting number

Remove Leading Zeros

Clean up each result by removing leading zeros

Find Minimum

Compare all results to find the lexicographically smallest

Code -

solution.c — C

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

char* removeKdigits(char* num, int k) {
    int n = strlen(num);
    if (k >= n) {
        char* result = malloc(2);
        strcpy(result, "0");
        return result;
    }
    
    char* minResult = NULL;
    int* positions = malloc(k * sizeof(int));
    
    void generateCombinations(int start, int depth) {
        if (depth == k) {
            char* result = malloc((n + 1) * sizeof(char));
            int resultIdx = 0;
            
            // Create set of positions to remove
            int removeSet[1000] = {0}; // Assuming max 1000 digits
            for (int i = 0; i < k; i++) {
                removeSet[positions[i]] = 1;
            }
            
            // Build result
            for (int i = 0; i < n; i++) {
                if (!removeSet[i]) {
                    result[resultIdx++] = num[i];
                }
            }
            result[resultIdx] = '\0';
            
            // Remove leading zeros
            int start = 0;
            while (start < resultIdx && result[start] == '0') start++;
            if (start == resultIdx) {
                strcpy(result, "0");
            } else {
                memmove(result, result + start, resultIdx - start + 1);
            }
            
            if (minResult == NULL || strcmp(result, minResult) < 0) {
                if (minResult) free(minResult);
                minResult = result;
            } else {
                free(result);
            }
            return;
        }
        
        for (int i = start; i <= n - (k - depth); i++) {
            positions[depth] = i;
            generateCombinations(i + 1, depth + 1);
        }
    }
    
    generateCombinations(0, 0);
    free(positions);
    
    if (minResult == NULL) {
        minResult = malloc(2);
        strcpy(minResult, "0");
    }
    
    return minResult;
}

int main() {
    char num[1001];
    int k;
    scanf("%s", num);
    scanf("%d", &k);
    
    char* result = removeKdigits(num, k);
    printf("%s\n", result);
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(C(n,k) * n)

We generate C(n,k) combinations and for each combination we process n digits

✓ Linear Growth

Space Complexity

O(n)

Space for storing the result string and temporary combinations

⚡ Linearithmic Space

Constraints

1 ≤ num.length ≤ 10⁴
0 ≤ k ≤ num.length
num consists of only digits
num does not have any leading zeros except for the zero itself

32.5K Views

Medium Frequency

~25 min Avg. Time

987 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler