Largest Number After Digit Swaps by Parity

Largest Number After Digit Swaps by Parity - Problem

Maximize Your Number Through Strategic Digit Swapping!

You're given a positive integer num and have a special power: you can swap any two digits that share the same parity (both odd or both even). Your mission is to rearrange the digits to create the largest possible number.

Key Rules:
• Even digits (0, 2, 4, 6, 8) can only swap with other even digits
• Odd digits (1, 3, 5, 7, 9) can only swap with other odd digits
• You can perform unlimited swaps

Goal: Return the maximum possible value after optimal swapping.

Example: Given 1234, you can swap 1↔3 and 2↔4 independently to get 3412.

Input & Output

example_1.py — Basic Case

$ Input: num = 1234

› Output: 3412

💡 Note: We can swap odd digits (1↔3) and even digits (2↔4) independently. The optimal arrangement puts the largest odd digit (3) first, largest even digit (4) second, remaining odd (1) third, and remaining even (2) last.

example_2.py — All Same Parity

$ Input: num = 65875

› Output: 87655

💡 Note: All digits are odd, so we can rearrange them in any order. To get the largest number, we sort them in descending order: [8,7,6,5,5].

example_3.py — Already Optimal

$ Input: num = 247

› Output: 427

💡 Note: Even digits: [2,4] → sort to [4,2]. Odd digits: [7] stays [7]. Reconstruction following original positions (odd,even,odd) gives us 427.

Visualization

Tap to expand

Understanding the Visualization

Identify Groups

Separate red dancers (odd digits) from blue dancers (even digits)

Sort by Height

Arrange each color group in descending order by height (digit value)

Reconstruct Formation

Place dancers back in their original color positions, but now optimally sorted

Key Takeaway

🎯 Key Insight: Since digits of the same parity can be rearranged freely, we simply need to sort each parity group in descending order and place them back optimally!

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Single sorting operation dominates the time complexity

⚡ Linearithmic

Space Complexity

O(1)

In-place sorting with only constant extra space

✓ Linear Space

Constraints

1 ≤ num ≤ 10⁹
num consists of positive digits only (no leading zeros)
The input is guaranteed to be a valid positive integer

Asked in

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

The optimal approach is to separate digits by parity (even/odd), sort each group in descending order, then reconstruct the number by placing the largest available digit of the correct parity at each position. This achieves O(n log n) time complexity with minimal space usage.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Separation and Sort	O(n log n)	O(n)	Separate digits by parity, sort each group, then reconstruct
Brute Force (Try All Swaps)	O(n!)	O(n)	Try all possible swaps recursively and track the maximum number
One-Pass In-Place Sorting (Optimal)	O(n log n)	O(1)	Directly sort digits in-place while maintaining parity constraints

Two-Pass Separation and Sort — Algorithm Steps

Convert number to digit array
Separate digits into even and odd lists
Sort both lists in descending order
Reconstruct number by placing largest available digit of correct parity at each position
Convert back to integer

Visualization

Tap to expand

Step-by-Step Walkthrough

Separate by Parity

Split digits into even and odd groups

Sort Each Group

Sort both groups in descending order

Reconstruct

Place largest available digit of correct parity at each position

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)b - *(int*)a); // Descending order
}

int largestInteger(int num) {
    char str[20];
    sprintf(str, "%d", num);
    int len = strlen(str);
    
    int evens[20], odds[20];
    int evenCount = 0, oddCount = 0;
    
    // First pass: separate by parity
    for (int i = 0; i < len; i++) {
        int digit = str[i] - '0';
        if (digit % 2 == 0) {
            evens[evenCount++] = digit;
        } else {
            odds[oddCount++] = digit;
        }
    }
    
    // Sort in descending order
    qsort(evens, evenCount, sizeof(int), compare);
    qsort(odds, oddCount, sizeof(int), compare);
    
    // Second pass: reconstruct with largest available digits
    char result[20];
    int evenIdx = 0, oddIdx = 0;
    
    for (int i = 0; i < len; i++) {
        int digit = str[i] - '0';
        if (digit % 2 == 0) {
            result[i] = '0' + evens[evenIdx++];
        } else {
            result[i] = '0' + odds[oddIdx++];
        }
    }
    result[len] = '\0';
    
    return atoi(result);
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Dominated by sorting the even and odd digit lists

⚡ Linearithmic

Space Complexity

O(n)

Need storage for even digits, odd digits, and result array

⚡ Linearithmic Space

Constraints

1 ≤ num ≤ 10⁹
num consists of positive digits only (no leading zeros)
The input is guaranteed to be a valid positive integer

42.4K Views

Medium 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two-Pass Separation and Sort — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler