Largest Number After Digit Swaps by Parity solution and explanation

def largest_integer(num):
    digits = list(str(num))
    odds = sorted((d for d in digits if int(d) % 2 != 0), reverse=True)
    evens = sorted((d for d in digits if int(d) % 2 == 0), reverse=True)
    
    for i, d in enumerate(digits):
        if int(d) % 2 == 0:
            digits[i] = evens.pop(0)
        else:
            digits[i] = odds.pop(0)
    
    return int(''.join(digits))

num = 1234
print(largest_integer(num))

import java.util.Arrays;

public class LargestInteger {
    public static int largestInteger(int num) {
        char[] digits = Integer.toString(num).toCharArray();
        char[] odds = new char[digits.length];
        char[] evens = new char[digits.length];
        int oddIndex = 0, evenIndex = 0;
        
        for (char digit : digits) {
            if ((digit - '0') % 2 == 0) evens[evenIndex++] = digit;
            else odds[oddIndex++] = digit;
        }

        Arrays.sort(odds, 0, oddIndex);
        Arrays.sort(evens, 0, evenIndex);
        
        reverse(odds, 0, oddIndex - 1);
        reverse(evens, 0, evenIndex - 1);

        oddIndex = 0; evenIndex = 0;
        for (int i = 0; i < digits.length; i++) {
            if ((digits[i] - '0') % 2 == 0) digits[i] = evens[evenIndex++];
            else digits[i] = odds[oddIndex++];
        }

        return Integer.parseInt(new String(digits));
    }

    private static void reverse(char[] arr, int start, int end) {
        while (start < end) {
            char temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
            start++;
            end--;
        }
    }

    public static void main(String[] args) {
        int num = 1234;
        System.out.println(largestInteger(num));
    }
}

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int largestInteger(int num) {
    string str = to_string(num);
    vector<char> odds, evens;
    for (char& ch : str) {
        if ((ch - '0') % 2 == 0) evens.push_back(ch);
        else odds.push_back(ch);
    }
    
    sort(odds.rbegin(), odds.rend());
    sort(evens.rbegin(), evens.rend());
    
    int oddIdx = 0, evenIdx = 0;
    for (char& ch : str) {
        if ((ch - '0') % 2 == 0) ch = evens[evenIdx++];
        else ch = odds[oddIdx++];
    }
    
    return stoi(str);
}

int main() {
    int num = 1234;
    cout << largestInteger(num) << endl;
    return 0;
}

function largestInteger(num) {
    let digits = num.toString().split('');
    let odds = digits.filter(d => d % 2 !== 0).sort((a, b) => b - a);
    let evens = digits.filter(d => d % 2 === 0).sort((a, b) => b - a);

    for (let i = 0; i < digits.length; i++) {
        if (digits[i] % 2 === 0) {
            digits[i] = evens.shift();
        } else {
            digits[i] = odds.shift();
        }
    }

    return parseInt(digits.join(''), 10);
}

console.log(largestInteger(1234));

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

int compare(const void *a, const void *b) {
    return *(char*)b - *(char*)a;
}

int largestInteger(int num) {
    char str[11];
    sprintf(str, "%d", num);

    char oddDigits[10] = {0};
    char evenDigits[10] = {0};
    int oddIndex = 0, evenIndex = 0;

    for (int i = 0; str[i] != '\0'; i++) {
        if ((str[i] - '0') % 2 == 0) {
            evenDigits[evenIndex++] = str[i];
        } else {
            oddDigits[oddIndex++] = str[i];
        }
    }

    qsort(oddDigits, oddIndex, sizeof(char), compare);
    qsort(evenDigits, evenIndex, sizeof(char), compare);

    oddIndex = 0; evenIndex = 0;

    for (int i = 0; str[i] != '\0'; i++) {
        if ((str[i] - '0') % 2 == 0) {
            str[i] = evenDigits[evenIndex++];
        } else {
            str[i] = oddDigits[oddIndex++];
        }
    }

    return atoi(str);
}

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

using System;
using System.Linq;

class LargestInteger {
    static int LargestInteger(int num) {
        char[] digits = num.ToString().ToCharArray();
        var evens = digits.Where(d => (d - '0') % 2 == 0).OrderByDescending(d => d).ToArray();
        var odds = digits.Where(d => (d - '0') % 2 != 0).OrderByDescending(d => d).ToArray();

        int evenIndex = 0, oddIndex = 0;
        for (int i = 0; i < digits.Length; i++) {
            if ((digits[i] - '0') % 2 == 0) digits[i] = evens[evenIndex++];
            else digits[i] = odds[oddIndex++];
        }

        return int.Parse(new string(digits));
    }

    static void Main() {
        int num = 1234;
        Console.WriteLine(LargestInteger(num));
    }
}

import heapq

def largest_integer(num):
    digits = list(str(num))
    odds = []
    evens = []

    for d in digits:
        if int(d) % 2 == 0:
            heapq.heappush(evens, -int(d)) # Max-heap behaviour by inverting
        else:
            heapq.heappush(odds, -int(d))

    result = []
    for d in digits:
        if int(d) % 2 == 0:
            result.append(str(-heapq.heappop(evens)))
        else:
            result.append(str(-heapq.heappop(odds)))

    return int(''.join(result))

num = 1234
print(largest_integer(num))

#include <iostream>
#include <vector>
#include <queue>
#include <string>
using namespace std;

int largestInteger(int num) {
    string str = to_string(num);
    priority_queue<int> odds, evens;

    for (char digit : str) {
        int val = digit - '0';
        if (val % 2 == 0) evens.push(val);
        else odds.push(val);
    }

    string result = "";
    for (char digit : str) {
        if ((digit - '0') % 2 == 0) {
            result += to_string(evens.top());
            evens.pop();
        } else {
            result += to_string(odds.top());
            odds.pop();
        }
    }
    
    return stoi(result);
}

int main() {
    int num = 1234;
    cout << largestInteger(num) << endl; // Output: 3412
    return 0;
}

function largestInteger(num: number): number {
    const s = num.toString().split('');
    const cnt = Array(10).fill(0);

    for (const c of s) {
        cnt[+c]++;
    }

    const idx = [8, 9];
    let ans = 0;

    for (const c of s) {
        const x = +c;
        while (cnt[idx[x % 2]] === 0) {
            idx[x % 2] -= 2;
        }
        ans = ans * 10 + idx[x % 2];
        cnt[idx[x % 2]]--;
    }

    return ans;
}

func largestInteger(num int) int {
	s := []byte(fmt.Sprint(num))
	cnt := [10]int{}

	for _, c := range s {
		cnt[c-'0']++
	}

	idx := [2]int{8, 9}
	ans := 0

	for _, c := range s {
		x := int(c - '0')
		for cnt[idx[x&1]] == 0 {
			idx[x&1] -= 2
		}
		ans = ans*10 + idx[x&1]
		cnt[idx[x&1]]--
	}

	return ans
}