Maximum Value after Insertion

Maximum Value after Insertion - Problem

String Greedy Medium

You are given a very large integer n, represented as a string, and an integer digit x. The digits in n and the digit x are in the inclusive range [1, 9], and n may represent a negative number.

You want to maximize n's numerical value by inserting x anywhere in the decimal representation of n. You cannot insert x to the left of the negative sign.

Examples:

If n = "73" and x = 6, it would be best to insert it between 7 and 3, making n = "763".
If n = "-55" and x = 2, it would be best to insert it before the first 5, making n = "-255".

Return a string representing the maximum value of n after the insertion.

Input & Output

Example 1 — Positive Number

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

› Output: "763"

💡 Note: Insert 6 before digit 3 (first digit < 6): 7 → 76 → 763. This gives maximum value 763.

Example 2 — Negative Number

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

› Output: "-255"

💡 Note: For negative numbers, insert before first digit > x: -5 → -25 → -255. This gives maximum value -255.

Example 3 — Append at End

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

› Output: "9995"

💡 Note: All digits (9) are ≥ 5, so append 5 at the end: 999 → 9995.

Constraints

1 ≤ n.length ≤ 10⁵
n consists of only digits, does not have leading zeros, and may have a leading negative sign
1 ≤ x ≤ 9

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Facebook 6

The key insight is to use different strategies for positive vs negative numbers. For positive numbers, insert x before the first digit smaller than x to maximize value. For negative numbers, insert x before the first digit larger than x to minimize the absolute value (thus maximizing the negative number). Best approach is greedy single pass with Time: O(n), Space: O(1).

Common Approaches

✓ Greedy Single Pass

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

For positive numbers, insert x before the first digit smaller than x. For negative numbers, insert x before the first digit larger than x. If no such digit exists, append to the end.

Try All Positions

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

Generate all possible strings by inserting x at each valid position (0 to n.length), then compare them numerically to find the maximum value.

Greedy Single Pass — Algorithm Steps

Check if number is positive or negative
Scan digits to find optimal insertion point
Insert x at the found position

Visualization

Tap to expand

Step-by-Step Walkthrough

Scan Left to Right

Look for first digit smaller than x

Insert at Position

Place x before the smaller digit

Result

Maximum value achieved

Code -

solution.c — C

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

char* solution(char* n, int x) {
    int len = strlen(n);
    char* result = malloc(len + 2);
    char xStr[2];
    sprintf(xStr, "%d", x);
    
    // Handle negative numbers
    if (n[0] == '-') {
        // For negative numbers, insert before first digit > x
        for (int i = 1; i < len; i++) {
            if ((n[i] - '0') > x) {
                strncpy(result, n, i);
                result[i] = '\0';
                strcat(result, xStr);
                strcat(result, n + i);
                return result;
            }
        }
        // If no digit > x found, append at end
        strcpy(result, n);
        strcat(result, xStr);
        return result;
    } else {
        // For positive numbers, insert before first digit < x
        for (int i = 0; i < len; i++) {
            if ((n[i] - '0') < x) {
                strncpy(result, n, i);
                result[i] = '\0';
                strcat(result, xStr);
                strcat(result, n + i);
                return result;
            }
        }
        // If no digit < x found, append at end
        strcpy(result, n);
        strcat(result, xStr);
        return result;
    }
}

int main() {
    char n[100];
    int x;
    
    fgets(n, sizeof(n), stdin);
    n[strcspn(n, "\n")] = 0; // Remove newline
    scanf("%d", &x);
    
    char* result = solution(n, x);
    printf("%s\n", result);
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string to find insertion position

✓ Linear Growth

Space Complexity

O(1)

Only uses constant extra space for variables

✓ Linear Space

23.5K Views

Medium Frequency

~15 min Avg. Time

847 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler