Largest Number After Mutating Substring - Practice Coding Problems

Largest Number After Mutating Substring - Problem

Imagine you're a digital magician working with a large number represented as a string. You have a magical change array that can transform any digit into another digit - think of it as a spell book where change[i] tells you what digit i should become.

Your mission: Choose exactly one contiguous substring from your number and apply the transformation to every digit in that substring. Your goal is to make the resulting number as large as possible.

For example, if your number is "132" and your change array maps [9,8,7,6,5,4,3,2,1,0], you could:

Transform the substring "13" → get "872"
Transform just "1" → get "932"
Or don't transform at all → keep "132"

The largest result would be "932"! Remember: you can choose not to transform if it would make the number smaller.

Input & Output

example_1.py — Basic Transformation

$ Input: num = "132", change = [9,8,7,6,5,4,3,2,1,0]

› Output: "867"

💡 Note: We can transform the entire string "132" to "867" since each digit can be improved: 1→8, 3→6, 2→7. This gives us the maximum possible value.

example_2.py — Partial Transformation

$ Input: num = "021", change = [9,8,7,6,5,4,3,2,1,0]

› Output: "934"

💡 Note: Transform "021" to "934". We change 0→9, 2→7, 1→8. Even though 2→7 makes it larger, we continue because it's beneficial, and 1→8 is also beneficial.

example_3.py — No Transformation

$ Input: num = "5", change = [1,4,2,3,0,5,6,7,8,9]

› Output: "5"

💡 Note: The digit 5 would change to 5 (no improvement), so we don't transform anything and return the original number.

Constraints

1 ≤ num.length ≤ 10⁵
change.length == 10
0 ≤ change[i] ≤ 9
num consists of only digits 0-9
You must choose exactly one substring (which can be empty - meaning no transformation)

Visualization

Tap to expand

Understanding the Visualization

Scan for Opportunity

Look from left to right for the first digit that can be improved

Start the Magic

Begin transformation at the first beneficial position

Continue the Spell

Keep transforming as long as digits improve or stay same

Stop Before Harm

Halt transformation before making any digit smaller

Key Takeaway

🎯 Key Insight: The greedy approach works because we want to maximize the leftmost digits first (highest impact), and once we start a transformation, we should continue it as long as it doesn't hurt the result.

Asked in

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

The optimal solution uses a greedy single-pass approach. Find the first digit that can be improved, then continue transforming consecutive digits while they can be improved or stay the same. Stop at the first digit that would become smaller. This O(n) solution works because leftmost digits have the highest impact on the number's value.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Single Pass (Optimal)	O(n)	O(n)	Find first improvable digit, extend transformation while beneficial
Brute Force (Try All Substrings)	O(n³)	O(n)	Try every possible substring transformation and return the largest result

Greedy Single Pass (Optimal) — Algorithm Steps

Scan from left to find the first digit that can be improved (change[d] > d)
Start transformation from this position
Continue transforming while change[d] >= d (beneficial or neutral)
Stop at the first digit where change[d] < d (would make number smaller)
If no improvable digit found, return original number

Visualization

Tap to expand

Step-by-Step Walkthrough

Find First Improvement

Scan left to right for first digit that can be improved

Start Transformation

Begin transforming from the first improvable position

Continue While Beneficial

Keep transforming while change[d] >= d

Stop at Decline

Stop when transformation would make digit smaller

Code -

solution.c — C

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

char* largestNumber(char* num, int* change, int changeSize) {
    int n = strlen(num);
    char* result = (char*)malloc((n + 1) * sizeof(char));
    strcpy(result, num);
    
    // Find the first digit that can be improved
    int start = -1;
    for (int i = 0; i < n; i++) {
        int digit = num[i] - '0';
        if (change[digit] > digit) {
            start = i;
            break;
        }
    }
    
    // If no digit can be improved, return original
    if (start == -1) {
        return result;
    }
    
    // Transform digits while beneficial or neutral
    for (int i = start; i < n; i++) {
        int digit = result[i] - '0';
        if (change[digit] >= digit) {
            result[i] = change[digit] + '0';
        } else {
            break; // Stop at first digit that would become smaller
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string to find start and end positions

✓ Linear Growth

Space Complexity

O(n)

Space for the output string (input modification creates new string)

⚡ Linearithmic Space

24.8K Views

Medium Frequency

~18 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

Greedy Single Pass (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler