Maximum Value after Insertion - Practice Coding Problems

Maximum Value after Insertion - Problem

String Greedy Medium

Maximum Value After Insertion

You're given a very large integer n represented as a string and a single digit x. Your goal is to strategically insert the digit x anywhere within the decimal representation of n to maximize the resulting numerical value.

🎯 Key Rules:
• All digits in n and the digit x are in range [1, 9]
• The number n can be positive or negative
• You cannot insert x to the left of the negative sign
• You must insert x exactly once

Examples:
• If n = "73" and x = 6 → Insert between 7 and 3 → "763"
• If n = "-55" and x = 2 → Insert before first 5 → "-255"

Return the string representing the maximum possible value after insertion.

Input & Output

example_1.py — Positive Number

$ Input: n = "73", x = 6

› Output: "763"

💡 Note: We can insert 6 at position 0 (673), position 1 (763), or position 2 (736). The maximum value is 763, achieved by inserting at position 1.

example_2.py — Negative Number

$ Input: n = "-55", x = 2

› Output: "-255"

💡 Note: For negative numbers, we want to minimize the absolute value. We can insert 2 at position 1 (-255) or position 2 (-525) or position 3 (-552). The maximum value (least negative) is -255.

example_3.py — Edge Case

$ Input: n = "999", x = 5

› Output: "9995"

💡 Note: Since 5 is smaller than all existing digits (9), we append it at the end to get the maximum value 9995.

Constraints

1 ≤ n.length ≤ 10⁵
1 ≤ x ≤ 9
The digits in n are in the range [1, 9]
n is a valid representation of an integer
n will not have leading zeros when it represents a positive integer

Visualization

Tap to expand

Understanding the Visualization

Assess the Situation

Determine if we're working with positive or negative numbers (different strategies needed)

Apply Greedy Strategy

For positive: place digit where it's bigger than current. For negative: place where it's smaller

Scan Left to Right

Check each position until we find the optimal placement

Insert and Finish

Place the digit at the identified position or append at end if no suitable position found

Key Takeaway

🎯 Key Insight: The greedy strategy works because the impact of each digit position decreases exponentially from left to right, making local optimal choices globally optimal.

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses a greedy approach with different strategies for positive and negative numbers. For positive numbers, we insert the digit at the first position where it's greater than the current digit to maximize the leftmost positions. For negative numbers, we insert the digit at the first position where it's smaller than the current digit to minimize the absolute value. This achieves O(n) time complexity with a single pass through the string.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Positions)	O(n²)	O(n)	Try inserting the digit at every possible position and compare results
Greedy One-Pass (Optimal)	O(n)	O(n)	Single pass with greedy strategy based on positive/negative cases

Brute Force (Try All Positions) — Algorithm Steps

Iterate through all possible insertion positions (0 to length of string)
For each position, create a new string with digit x inserted
Convert each resulting string to a number for comparison
Keep track of the maximum value and its corresponding string
Return the string that produces the maximum numerical value

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Position 0

Insert digit at the beginning (skip if negative)

Try Position 1

Insert digit after first character

Try Position 2

Insert digit after second character

Compare Results

Find the position that gives maximum value

Code -

solution.c — C

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

char* maxValue(char* n, int x) {
    int len = strlen(n);
    char* result = (char*)malloc((len + 2) * sizeof(char));
    long long maxVal = LLONG_MIN;
    int found = 0;
    
    // Try inserting at every possible position
    for (int i = 0; i <= len; i++) {
        // Skip position 0 if string starts with '-'
        if (i == 0 && n[0] == '-') {
            continue;
        }
        
        // Create new string with x inserted at position i
        char* newStr = (char*)malloc((len + 2) * sizeof(char));
        strncpy(newStr, n, i);
        newStr[i] = '0' + x;
        strcpy(newStr + i + 1, n + i);
        
        // Compare values
        long long val = atoll(newStr);
        if (!found || val > maxVal) {
            maxVal = val;
            strcpy(result, newStr);
            found = 1;
        }
        
        free(newStr);
    }
    
    return result;
}

int main() {
    char n[100000];
    int x;
    fgets(n, sizeof(n), stdin);
    // Remove quotes and newline
    n[strlen(n)-1] = '\0';
    if (n[0] == '"') {
        memmove(n, n+1, strlen(n));
        n[strlen(n)-1] = '\0';
    }
    scanf("%d", &x);
    
    char* result = maxValue(n, x);
    printf("\"%s\"", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We try n+1 positions, and for each position we create a new string of length n+1, plus string comparison takes O(n) time

⚠ Quadratic Growth

Space Complexity

O(n)

We store multiple string copies, each of length n+1

⚡ Linearithmic Space

67.2K Views

Medium-High Frequency

~15 min Avg. Time

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

Brute Force (Try All Positions) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler