Largest Number After Digit Swaps by Parity

Largest Number After Digit Swaps by Parity - Problem

You are given a positive integer num. You may swap any two digits of num that have the same parity (i.e. both odd digits or both even digits).

Return the largest possible value of num after performing any number of such swaps.

Note: Digits with the same parity can be rearranged in any order to maximize the number.

Input & Output

Example 1 — Basic Case

$ Input: num = 1234

› Output: 3412

💡 Note: Odd digits [1,3] sorted descending become [3,1], even digits [2,4] sorted descending become [4,2]. Maintaining original positions: 3412

Example 2 — Same Parity Only

$ Input: num = 65875

› Output: 87655

💡 Note: Odd digits [5,7,5] sorted descending: [7,5,5]. Even digits [6,8] sorted: [8,6]. Result: 87655

Example 3 — Already Optimal

$ Input: num = 247

› Output: 427

💡 Note: Even digits [2,4] become [4,2], odd digit [7] stays. Result: 427

Constraints

1 ≤ num ≤ 10⁹
num consists of digits only

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12

The key insight is that digits with the same parity can be rearranged freely. The optimal approach separates digits by parity, sorts each group in descending order, then reconstructs the number. Time: O(n log n), Space: O(n)

Common Approaches

✓ Hash Map

⏱️ Time: N/A Space: N/A

Brute Force - Try All Swaps

⏱️ Time: O(n! × n) Space: O(n)

Convert number to string, try all possible swaps between digits of same parity, and keep track of the maximum number achieved. Continue until no more improvements can be made.

Sort by Parity - Optimal

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

Extract all digits and separate them into odd and even groups. Sort each group in descending order to maximize value. Then reconstruct the number by placing sorted digits back in their original parity positions.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

long long solution(long long num) {
    char digits[20];
    sprintf(digits, "%lld", num);
    int n = strlen(digits);
    long long max_num = num;
    
    // Try all possible swaps
    bool changed = true;
    while (changed) {
        changed = false;
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                // Check if digits have same parity
                int digit_i = digits[i] - '0';
                int digit_j = digits[j] - '0';
                if (digit_i % 2 == digit_j % 2) {
                    // Try swap
                    char temp = digits[i];
                    digits[i] = digits[j];
                    digits[j] = temp;
                    
                    long long current_num = strtoll(digits, NULL, 10);
                    if (current_num > max_num) {
                        max_num = current_num;
                        changed = true;
                    } else {
                        // Revert swap
                        digits[j] = digits[i];
                        digits[i] = temp;
                    }
                }
            }
        }
    }
    
    return max_num;
}

int main() {
    char line[100];
    fgets(line, sizeof(line), stdin);
    long long num = strtoll(line, NULL, 10);
    
    long long result = solution(num);
    printf("%lld\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

⚡ Linearithmic Space

23.4K Views

Medium Frequency

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