Maximum Difference by Remapping a Digit - Practice Coding Problems

Maximum Difference by Remapping a Digit - Problem

Math Greedy Easy

You're given an integer num and Bob, a sneaky character, has the ability to remap exactly one digit (0-9) to any other digit of his choice.

Goal: Find the maximum possible difference between the largest and smallest numbers Bob can create by remapping digits.

Key Rules:

Bob must remap exactly one digit type - all occurrences of that digit get replaced
Bob can use different remapping strategies for maximum vs minimum values
Leading zeros are allowed in the result
Bob can remap a digit to itself (no change)

Example: For num = 11111, Bob can remap all 1's to 9's for maximum (99999) and all 1's to 0's for minimum (00000 = 0), giving difference = 99999.

Input & Output

example_1.py — Basic Case

$ Input: num = 123

› Output: 820

💡 Note: For maximum: change first non-9 digit (1) to 9 → 923. For minimum: change first digit (1) to 1 → no change, so find first non-0,non-1 digit (2) and change to 0 → 103. Difference: 923 - 103 = 820.

example_2.py — All Same Digits

$ Input: num = 555

› Output: 888

💡 Note: For maximum: change 5 to 9 → 999. For minimum: since first digit is 5 (not 1), change 5 to 1 → 111. Difference: 999 - 111 = 888.

example_3.py — Edge Case with 9s

$ Input: num = 9321

› Output: 8970

💡 Note: For maximum: first digit is already 9, next non-9 is 3, change to 9 → 9921. For minimum: first digit is 9 (not 1), so change 9 to 1 → 1321. Difference: 9921 - 1321 = 8600.

Constraints

1 ≤ num ≤ 10⁸
num does not contain any leading zeros

Visualization

Tap to expand

Understanding the Visualization

Scan for Maximum Impact

For maximum value, scan left-to-right to find the first digit that isn't already 9

Apply Maximum Transform

Transform all occurrences of that digit to 9 for maximum boost

Strategic Minimum Approach

For minimum, if first digit > 1, change to 1; else find first digit > 1 and change to 0

Calculate the Difference

The difference between these optimal transformations is our answer

Key Takeaway

🎯 Key Insight: Greedy works perfectly because digit position determines exponential value impact - optimizing the leftmost digits gives maximum benefit!

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 12 Apple 8

The optimal solution uses a greedy approach that leverages the positional importance of digits. For maximum value, find the first digit that isn't 9 and remap it to 9. For minimum value, if the first digit isn't 1, remap it to 1; otherwise, find the first digit that isn't 0 or 1 and remap it to 0. This works because leftmost digits have exponentially more impact on the final value than rightmost digits.

Common Approaches

Approach	Time	Space	Notes
✓ Optimal Greedy (Single Pass)	O(d)	O(d)	Use greedy strategy to find optimal remappings for max and min in one pass
Brute Force (Try All Combinations)	O(100 × d)	O(d)	Try remapping every digit to every other digit and track max/min results

Optimal Greedy (Single Pass) — Algorithm Steps

Convert number to string for easy digit access
Find maximum: scan left-to-right for first digit < 9, change all instances to 9
Find minimum: if first digit > 1, change to 1; else find first digit > 1 that isn't 0, change to 0
Handle edge case: if all digits are the same, remap appropriately
Calculate and return the difference

Visualization

Tap to expand

Step-by-Step Walkthrough

Analyze digit positions

Leftmost digits have highest impact

Maximize greedily

Find first non-9 digit, change to 9

Minimize strategically

Change first digit to 1, or find first non-0,1 digit

Calculate difference

Subtract minimum from maximum

Code -

solution.c — C

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

int maxDiff(int num) {
    char numStr[20];
    sprintf(numStr, "%d", num);
    int len = strlen(numStr);
    
    // Find maximum value
    char maxStr[20];
    strcpy(maxStr, numStr);
    for (int i = 0; i < len; i++) {
        if (numStr[i] != '9') {
            char digit = numStr[i];
            for (int j = 0; j < len; j++) {
                if (maxStr[j] == digit) maxStr[j] = '9';
            }
            break;
        }
    }
    
    // Find minimum value
    char minStr[20];
    strcpy(minStr, numStr);
    if (numStr[0] != '1') {
        // Replace first digit with '1'
        char firstDigit = numStr[0];
        for (int j = 0; j < len; j++) {
            if (minStr[j] == firstDigit) minStr[j] = '1';
        }
    } else {
        // First digit is '1', find first digit that's not '0' or '1'
        for (int i = 0; i < len; i++) {
            if (numStr[i] != '0' && numStr[i] != '1') {
                char digit = numStr[i];
                for (int j = 0; j < len; j++) {
                    if (minStr[j] == digit) minStr[j] = '0';
                }
                break;
            }
        }
    }
    
    return atoi(maxStr) - atoi(minStr);
}

int main() {
    int num;
    scanf("%d", &num);
    printf("%d\n", maxDiff(num));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(d)

Single pass through the d digits to find optimal remapping, plus O(d) for each replacement operation

✓ Linear Growth

Space Complexity

O(d)

Space needed to store string representation of the d-digit number

✓ Linear Space

23.4K 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

Constraints

Visualization

Related Problems

Common Approaches

Optimal Greedy (Single Pass) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler