Advantage Shuffle solution and explanation

def advantage_count(nums1, nums2):
    nums1.sort()
    sorted_indices = sorted(range(len(nums2)), key=lambda i: nums2[i])
    result = [-1] * len(nums1)
    left, right = 0, len(nums1) - 1
    for num in nums1:
        if num > nums2[sorted_indices[left]]:
            result[sorted_indices[left]] = num
            left += 1
        else:
            result[sorted_indices[right]] = num
            right -= 1
    return result

#include <vector>
#include <algorithm>
#include <queue>

std::vector<int> advantageCount(std::vector<int>& nums1, std::vector<int>& nums2) {
    std::sort(nums1.begin(), nums1.end());
    std::priority_queue<std::pair<int, int>> pq;
    for (int i = 0; i < nums2.size(); ++i) {
        pq.emplace(nums2[i], i);
    }
    int left = 0, right = nums1.size() - 1;
    std::vector<int> result(nums1.size());
    while (!pq.empty()) {
        auto [num, i] = pq.top(); pq.pop();
        if (nums1[right] > num) {
            result[i] = nums1[right--];
        } else {
            result[i] = nums1[left++];
        }
    }
    return result;
}

import java.util.*;

public class AdvantageShuffle {
    public int[] advantageCount(int[] nums1, int[] nums2) {
        Arrays.sort(nums1);
        TreeMap<Integer, Integer> map = new TreeMap<>();
        for (int num : nums1) {
            map.put(num, map.getOrDefault(num, 0) + 1);
        }
        int[] result = new int[nums1.length];
        for (int i = 0; i < nums2.length; i++) {
            Integer key = map.higherKey(nums2[i]);
            if (key == null) key = map.firstKey();
            result[i] = key;
            map.put(key, map.get(key) - 1);
            if (map.get(key) == 0) map.remove(key);
        }
        return result;
    }
}

using System;
using System.Collections.Generic;

public class Solution {
    public int[] AdvantageCount(int[] nums1, int[] nums2) {
        Array.Sort(nums1);
        SortedDictionary<int, int> dict = new SortedDictionary<int, int>();
        foreach (var num in nums1) {
            if (!dict.ContainsKey(num))
                dict[num] = 0;
            dict[num]++;
        }
        int[] result = new int[nums1.Length];
        for (int i = 0; i < nums2.Length; i++) {
            var key = dict.Keys.FirstOrDefault(k => k > nums2[i]);
            if (key == default(int))
                key = dict.Keys.First();
            result[i] = key;
            if (--dict[key] == 0)
                dict.Remove(key);
        }
        return result;
    }
}

function advantageCount(nums1: number[], nums2: number[]): number[] {
    const n = nums1.length;
    const idx = Array.from({ length: n }, (_, i) => i);
    idx.sort((i, j) => nums2[i] - nums2[j]);
    nums1.sort((a, b) => a - b);

    const ans = new Array(n).fill(0);
    let left = 0;
    let right = n - 1;
    for (let i = 0; i < n; i++) {
        if (nums1[i] > nums2[idx[left]]) {
            ans[idx[left]] = nums1[i];
            left++;
        } else {
            ans[idx[right]] = nums1[i];
            right--;
        }
    }
    return ans;
}

func advantageCount(nums1 []int, nums2 []int) []int {
	n := len(nums1)
	t := make([][]int, n)
	for i, v := range nums2 {
		t[i] = []int{v, i}
	}
	sort.Slice(t, func(i, j int) bool {
		return t[i][0] < t[j][0]
	})
	sort.Ints(nums1)
	ans := make([]int, n)
	i, j := 0, n-1
	for _, v := range nums1 {
		if v <= t[i][0] {
			ans[t[j][1]] = v
			j--
		} else {
			ans[t[i][1]] = v
			i++
		}
	}
	return ans
}

impl Solution {
    pub fn advantage_count(mut nums1: Vec<i32>, nums2: Vec<i32>) -> Vec<i32> {
        let n = nums1.len();
        let mut idx = (0..n).collect::<Vec<usize>>();
        idx.sort_by(|&i, &j| nums2[i].cmp(&nums2[j]));
        nums1.sort();
        let mut res = vec![0; n];
        let mut left = 0;
        let mut right = n - 1;
        for &num in nums1.iter() {
            if num > nums2[idx[left]] {
                res[idx[left]] = num;
                left += 1;
            } else {
                res[idx[right]] = num;
                right -= 1;
            }
        }
        res
    }
}