Clear Digits

Clear Digits - Problem

You are given a string s. Your task is to remove all digits by doing this operation repeatedly:

Delete the first digit and the closest non-digit character to its left.

Return the resulting string after removing all digits.

Note that the operation cannot be performed on a digit that does not have any non-digit character to its left.

Input & Output

Example 1 — Basic Case

$ Input: s = "abc3def2"

› Output: "abde"

💡 Note: First digit '3': remove '3' and closest left non-digit 'c' → "ab_def2". Next digit '2': remove '2' and closest left non-digit 'f' → "abde"

Example 2 — Digit Without Left Non-Digit

$ Input: s = "2ab3"

› Output: "a"

💡 Note: First digit '2': no non-digit to its left, remove only '2' → "ab3". Next digit '3': remove '3' and closest left non-digit 'b' → "a"

Example 3 — All Digits

$ Input: s = "123"

› Output: "123"

💡 Note: No non-digit characters exist, so no digits can be removed. Return original string

Constraints

1 ≤ s.length ≤ 1000
s consists of lowercase English letters and digits

Visualization

Tap to expand

Asked in

M Microsoft 15 A Amazon 12

The key insight is that when we encounter a digit, we need to remove it along with the closest non-digit character to its left. A stack-based approach elegantly solves this by naturally maintaining access to the most recent non-digit character. Time: O(n), Space: O(n).

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Brute Force Simulation

⏱️ Time: O(n²) Space: O(n)

For each iteration, scan the string to find the first digit, then scan backwards from that position to find the closest non-digit character. Remove both characters and repeat until no digits remain.

Stack-Based Solution

⏱️ Time: O(n) Space: O(n)

Process the string from left to right. Push non-digit characters onto a stack. When encountering a digit, pop the top element from the stack (if not empty) and skip the digit. The stack naturally maintains the closest non-digit to the left.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

char* clearDigits(char* s) {
    static char result[1001];
    int top = -1; // Stack pointer
    int len = strlen(s);
    
    for (int i = 0; i < len; i++) {
        if (isdigit(s[i])) {
            // If current character is digit and we have non-digit on stack, remove it
            if (top >= 0) {
                top--; // Remove last character from stack
            } else {
                // No non-digit to remove, keep the digit
                result[++top] = s[i];
            }
        } else {
            // If current character is non-digit, add to stack
            result[++top] = s[i];
        }
    }
    
    result[top + 1] = '\0'; // Null terminate
    return result;
}

int main() {
    char s[1001];
    scanf("%s", s);
    
    char* result = clearDigits(s);
    printf("%s\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

29.8K Views

Medium Frequency

~15 min Avg. Time

850 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