Clear Digits - Practice Coding Problems

Clear Digits - Problem

You're given a string containing both letters and digits mixed together. Your task is to eliminate all digits by repeatedly applying a specific removal rule:

Find the first digit in the string
Remove both the digit AND the closest non-digit character to its left
Repeat until no more digits can be removed

Important: If a digit has no non-digit character to its left, it cannot be removed and will remain in the final string.

Example: In "abc3def2", we first remove digit '3' and its closest left non-digit 'c', giving us "ab_def2". Then we remove '2' and 'f', resulting in "ab_de".

Input & Output

example_1.py — Basic Case

$ Input: s = "abc3def2"

› Output: "abde"

💡 Note: First, we remove '3' and its closest left non-digit 'c', getting 'ab_def2'. Then we remove '2' and 'f', resulting in 'abde'.

example_2.py — Leading Digits

$ Input: s = "123abc"

› Output: "123abc"

💡 Note: The digits '1', '2', '3' have no non-digit characters to their left, so they cannot be removed. The string remains unchanged.

example_3.py — All Removable

$ Input: s = "a1b2c3"

› Output: ""

💡 Note: We can remove all digits: '1' removes 'a', '2' removes 'b', '3' removes 'c', leaving an empty string.

Visualization

Tap to expand

Understanding the Visualization

Type Characters

As we type non-digit characters, they appear on screen (get added to stack)

Hit 'Digit Backspace'

When we press a digit key, it acts like backspace - removes the last character and itself

Smart Deletion

The stack automatically tracks which character to delete (top of stack = most recent)

Final Text

What remains on screen is our final result after all digit-backspaces

Key Takeaway

🎯 Key Insight: The stack approach is optimal because it naturally maintains the order of characters and provides O(1) access to the "closest left non-digit" character, eliminating the need for repeated string operations.

Time & Space Complexity

Time Complexity

⏱️

O(n)

We process each character exactly once, and each stack operation is O(1)

✓ Linear Growth

Space Complexity

O(n)

In worst case (no digits), we store all characters in the stack

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 100
s consists of lowercase English letters and digits
The given operation can be performed on the string at most s.length times

Asked in

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

The optimal approach uses a stack data structure to simulate the removal process efficiently. Instead of repeatedly scanning and modifying the string, we process each character once: push non-digits onto the stack, and when we encounter a digit, simply pop from the stack if possible. This achieves O(n) time complexity with a single pass through the string.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Repeated String Operations)	O(n²)	O(n)	Repeatedly scan string to find first digit and remove it with closest left non-digit
Stack Approach (Optimal)	O(n)	O(n)	Use stack to track characters and efficiently remove digit-character pairs

Brute Force (Repeated String Operations) — Algorithm Steps

Start with the original string
Scan from left to find the first digit
If digit found, scan backwards to find closest non-digit
Remove both characters and create new string
Repeat until no more digits can be removed

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial String

Start with input string 'abc3def2'

Find First Digit

Scan to find first digit '3' at position 3

Find Left Non-digit

Look backwards from digit to find 'c' at position 2

Remove Both

Remove both 'c' and '3', creating 'ab_def2'

Repeat Process

Start over and find next digit '2'

Code -

solution.c — C

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

char* clearDigits(char* s) {
    int len = strlen(s);
    
    while (1) {
        // Find first digit
        int digitPos = -1;
        for (int i = 0; i < len; i++) {
            if (isdigit(s[i])) {
                digitPos = i;
                break;
            }
        }
        
        if (digitPos == -1) break; // No more digits
        
        // Find closest non-digit to the left
        int leftPos = -1;
        for (int i = digitPos - 1; i >= 0; i--) {
            if (!isdigit(s[i])) {
                leftPos = i;
                break;
            }
        }
        
        if (leftPos == -1) break; // No non-digit to left
        
        // Remove both characters
        memmove(&s[leftPos], &s[leftPos + 1], digitPos - leftPos - 1);
        memmove(&s[digitPos - 1], &s[digitPos + 1], len - digitPos - 1);
        len -= 2;
        s[len] = '\0';
    }
    
    return s;
}

int main() {
    char input[1001];
    fgets(input, sizeof(input), stdin);
    
    // Remove newline and quotes
    int len = strlen(input);
    if (input[len-1] == '\n') input[--len] = '\0';
    if (input[0] == '"') {
        memmove(input, input + 1, len - 1);
        input[len - 2] = '\0';
    }
    
    char* result = clearDigits(input);
    printf("\"%s\"\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

In worst case, we might need n/2 iterations, and each iteration scans up to n characters

⚠ Quadratic Growth

Space Complexity

O(n)

Space needed to create new strings in each iteration

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 100
s consists of lowercase English letters and digits
The given operation can be performed on the string at most s.length times

24.6K Views

Medium Frequency

~15 min Avg. Time

892 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 (Repeated String Operations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler