Remove Digit From Number to Maximize Result

Remove Digit From Number to Maximize Result - Problem

Remove Digit From Number to Maximize Result

Imagine you have a large number as a string, and you need to strategically remove exactly one specific digit to create the largest possible number. This is like editing a phone number or account ID where removing one digit in the right position can make a huge difference!

🎯 Your Goal: Given a string number representing a positive integer and a character digit, remove exactly one occurrence of digit to maximize the resulting number's value.

📝 Key Points:
• You must remove exactly one occurrence of the specified digit
• The goal is to maximize the decimal value of the result
• The digit is guaranteed to exist in the number
• Return the result as a string

Example: If number = "123" and digit = '3', removing the '3' gives "12". But if number = "1321" and digit = '1', you could remove the first '1' to get "321" or the last '1' to get "132" - choose "321" since it's larger!

Input & Output

example_1.py — Basic Case

$ Input: number = "123", digit = "3"

› Output: "12"

💡 Note: There's only one occurrence of '3', so we remove it to get "12"

example_2.py — Multiple Occurrences

$ Input: number = "1231", digit = "1"

› Output: "231"

💡 Note: We can remove '1' from position 0 to get "231" or from position 3 to get "123". Since "231" > "123", we return "231"

example_3.py — Greedy Choice

$ Input: number = "551", digit = "5"

› Output: "51"

💡 Note: Remove the first '5' because the next digit '5' is not larger. Continue to second '5' where next digit '1' is smaller. Remove the last '5' to get "51"

Visualization

Tap to expand

Understanding the Visualization

Identify Target

Find the digit that needs to be removed from the number string

Greedy Strategy

Look for positions where removing the digit allows a larger digit to move forward

Make Decision

Remove at the first beneficial position, or remove the last occurrence if none found

Key Takeaway

🎯 Key Insight: Remove a digit when it blocks a larger digit from moving to a more significant position, maximizing the overall value!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through string, each character examined once

✓ Linear Growth

Space Complexity

O(1)

Only storing indices and creating one result string

✓ Linear Space

Constraints

2 ≤ number.length ≤ 100
number consists of digits from '1' to '9'
digit is a digit from '1' to '9'
digit occurs at least once in number

Asked in

a Amazon 25 G Google 18 ⊞ Microsoft 15 f Meta 12

The optimal greedy approach solves this in O(n) time by making a single pass through the string. The key insight is to remove the first occurrence of the digit where the next digit is larger, allowing that larger digit to move to an earlier position and maximize the result. If no such beneficial position exists, remove the last occurrence to preserve as many significant digits as possible.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force - Try All Positions	O(n²)	O(n)	Generate all possible results by removing each occurrence of the digit, then find maximum
Greedy Single Pass (Optimal)	O(n)	O(1)	Remove the first occurrence where digit is less than next digit, or last occurrence otherwise

Brute Force - Try All Positions — Algorithm Steps

Find all positions where the target digit appears in the string
For each position, create a new string with that digit removed
Convert each resulting string to compare their values
Return the string that produces the maximum numerical value

Visualization

Tap to expand

Step-by-Step Walkthrough

Find All Positions

Locate all occurrences of target digit '1' in "1321"

Generate Results

Remove digit from position 0: "321", from position 2: "132"

Compare and Select

Compare "321" vs "132" - select "321" as maximum

Code -

solution.c — C

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

char* removeDigit(char* number, char digit) {
    int len = strlen(number);
    char** results = malloc(len * sizeof(char*));
    int count = 0;
    
    // Find all positions of the digit
    for (int i = 0; i < len; i++) {
        if (number[i] == digit) {
            // Create result string without digit at position i
            char* result = malloc(len * sizeof(char));
            strncpy(result, number, i);
            strcpy(result + i, number + i + 1);
            results[count++] = result;
        }
    }
    
    // Find maximum result
    char* maxResult = results[0];
    for (int i = 1; i < count; i++) {
        if (strcmp(results[i], maxResult) > 0) {
            maxResult = results[i];
        }
    }
    
    // Copy to return value
    char* finalResult = malloc(len * sizeof(char));
    strcpy(finalResult, maxResult);
    
    // Free memory
    for (int i = 0; i < count; i++) {
        free(results[i]);
    }
    free(results);
    
    return finalResult;
}

int main() {
    char number[1000], digit;
    scanf("\"%s\" \"%c\"", number, &digit);
    
    char* result = removeDigit(number, digit);
    printf("\"%s\"", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n) to find positions × O(n) to create each string × O(n) to compare strings

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing intermediate result strings

⚡ Linearithmic Space

Constraints

2 ≤ number.length ≤ 100
number consists of digits from '1' to '9'
digit is a digit from '1' to '9'
digit occurs at least once in number

26.8K 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 - Try All Positions — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler