Max Difference You Can Get From Changing an Integer

Max Difference You Can Get From Changing an Integer - Problem

Math Greedy Medium

You are given an integer num. You will apply the following steps to num two separate times:

Pick a digit x (0 ≤ x ≤ 9).
Pick another digit y (0 ≤ y ≤ 9). Note y can be equal to x.
Replace all the occurrences of x in the decimal representation of num by y.

Let a and b be the two results from applying the operation to num independently.

Return the maximum difference between a and b.

Note that neither a nor b may have any leading zeros, and must not be 0.

Input & Output

Example 1 — Basic Case

$ Input: num = 555

› Output: 888

💡 Note: To maximize: all digits are 5 (not 9), so replace 5→9 to get 999. To minimize: first digit is 5≠1, so replace 5→1 to get 111. Difference: 999 - 111 = 888

Example 2 — First Digit is 9

$ Input: num = 901

› Output: 890

💡 Note: To maximize: first digit is 9, second digit is 0 (not 9), so replace 0→9 to get 991. To minimize: first digit 9≠1, so replace 9→1 to get 101. Difference: 991 - 101 = 890

Example 3 — Edge Case with 1

$ Input: num = 123

› Output: 820

💡 Note: To maximize: first digit 1 (not 9), so replace 1→9 to get 923. To minimize: first digit 1≠1 is false, so find next non-0/1 digit which is 2, replace 2→0 to get 103. Difference: 923 - 103 = 820

Constraints

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

Visualization

Tap to expand

Asked in

G Google 35 M Microsoft 28 a Amazon 22

The key insight is that leftmost digits have the highest impact on a number's value. For maximum value, find the first non-9 digit and replace it with 9. For minimum value, if the first digit is not 1, replace it with 1; otherwise find the first digit that's not 0 or 1 and replace it with 0. Best approach is greedy strategy. Time: O(n), Space: O(n)

Common Approaches

✓ Sort First

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

Brute Force

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

For each digit position (0-9) and each replacement digit (0-9), perform the replacement operation and track the maximum and minimum results. Calculate the difference between them.

Greedy Approach

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

To maximize: find the first digit from left that's not 9 and change it to 9. To minimize: if first digit is not 1, change it to 1; otherwise find first digit that's not 0 or 1 and change it to 0.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int popCount(int x) {
    int count = 0;
    while (x) {
        count += x & 1;
        x >>= 1;
    }
    return count;
}

int solution(int* nums, int numsSize, int k) {
    const int MOD = 1000000007;
    long long total = 0;
    
    // Generate all subsequences using bit manipulation
    for (int mask = 1; mask < (1 << numsSize); mask++) {
        if (popCount(mask) > k) continue;
        
        int maxVal = INT_MIN, minVal = INT_MAX;
        int hasElement = 0;
        
        for (int i = 0; i < numsSize; i++) {
            if (mask & (1 << i)) {
                hasElement = 1;
                if (nums[i] > maxVal) maxVal = nums[i];
                if (nums[i] < minVal) minVal = nums[i];
            }
        }
        
        if (hasElement) {
            total = (total + maxVal + minVal) % MOD;
        }
    }
    
    // Ensure positive result
    return (int) (((total % MOD) + MOD) % MOD);
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[20];
    int numsSize = 0;
    char* token = strtok(line, "[],\n ");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    int k;
    scanf("%d", &k);
    
    int result = solution(nums, numsSize, k);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

32.0K Views

Medium Frequency

~15 min Avg. Time

856 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