Maximum Swap - Practice Coding Problems

Maximum Swap - Problem

Math Greedy Medium

You're given an integer num, and you have exactly one opportunity to make a single swap between any two digits to create the largest possible number.

Goal: Maximize the value of the number by strategically swapping two digits at most once.

For example, if you have 2736, you could swap the 2 and 7 to get 7236, which is the maximum possible value with one swap.

Key Insight: You want to move the largest possible digit as far left as possible, while moving a smaller digit as far right as possible.

Input & Output

example_1.py — Basic Swap

$ Input: num = 2736

› Output: 7236

💡 Note: Swapping digits at positions 0 and 1 gives us the maximum number. We swap '2' and '7' to get 7236, which is the largest possible number with one swap.

example_2.py — No Beneficial Swap

$ Input: num = 9973

› Output: 9973

💡 Note: The number is already in descending order from left to right, so no single swap can make it larger. The function returns the original number.

example_3.py — Multiple Same Digits

$ Input: num = 98368

› Output: 98863

💡 Note: We swap the '3' at position 2 with the '8' at position 4 to get 98863. This gives us the maximum possible improvement by moving the largest available digit (8) to the leftmost position where it can make a difference.

Visualization

Tap to expand

Understanding the Visualization

Identify the VIP

Scan from right to left to find the highest-value digit that could benefit from moving left

Find the Best Position

Locate the leftmost position where swapping would create maximum value increase

Execute the Swap

Perform the single most beneficial swap to maximize the number's value

Key Takeaway

🎯 Key Insight: By scanning right-to-left and tracking the maximum digit, we can identify the optimal swap position in a single pass, ensuring we move the highest-value digit to the leftmost position where it creates maximum impact.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the digit array from right to left

✓ Linear Growth

Space Complexity

O(n)

Only need space for the digit array representation

⚡ Linearithmic Space

Constraints

0 ≤ num ≤ 10⁸
The input number will have at most 8 digits
You can swap at most once - choose wisely!

Asked in

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

The optimal solution uses a single pass from right to left to track the maximum digit seen so far. When we encounter a digit smaller than the maximum to its right, we mark it as a potential swap position. The key insight is that we want the leftmost such position to maximize the impact of our swap. This greedy approach achieves O(n) time and O(n) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Swaps)	O(n²)	O(n)	Try every possible pair of digit positions and find the maximum result
Two-Pass with Last Position Tracking	O(n)	O(1)	First pass to record last position of each digit, second pass to find optimal swap
Single Pass with Max Tracking (Optimal)	O(n)	O(n)	Track maximum digit and its position while scanning right to left, then find best swap position

Brute Force (Try All Swaps) — Algorithm Steps

Convert the number to a string to access individual digits
Try swapping every pair of positions (i, j) where i < j
For each swap, convert back to integer and compare with current maximum
Return the maximum number found, or original if no improvement

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert to Array

Convert number 2736 to digit array [2,7,3,6]

Try Swap (0,1)

Swap positions 0,1: [7,2,3,6] = 7236

Try Swap (0,2)

Swap positions 0,2: [3,7,2,6] = 3726

Continue All Pairs

Try all remaining combinations and track maximum

Code -

solution.c — C

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

int maximumSwap(int num) {
    char digits[12];
    sprintf(digits, "%d", num);
    int len = strlen(digits);
    int maxNum = num;
    
    for (int i = 0; i < len; i++) {
        for (int j = i + 1; j < len; j++) {
            // Swap digits at positions i and j
            char temp = digits[i];
            digits[i] = digits[j];
            digits[j] = temp;
            
            // Convert back to integer and update max
            int current = atoi(digits);
            if (current > maxNum) {
                maxNum = current;
            }
            
            // Swap back to restore original state
            temp = digits[i];
            digits[i] = digits[j];
            digits[j] = temp;
        }
    }
    
    return maxNum;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We try all pairs of positions, which is n*(n-1)/2 combinations

⚠ Quadratic Growth

Space Complexity

O(n)

We need space to store the string representation of the number

⚡ Linearithmic Space

Constraints

0 ≤ num ≤ 10⁸
The input number will have at most 8 digits
You can swap at most once - choose wisely!

42.0K Views

Medium-High Frequency

~15 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Swaps) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler