870. Advantage Shuffle

public class Solution {
    public int[] AdvantageCount(int[] A, int[] B) {
        var sortedA = A.OrderBy(x => x).ToArray();
        var sortedB = B.Select((x, i) => new { Value = x, Index = i }).OrderBy(x => x.Value).ToArray();
        var assigned = new Dictionary<int, Queue<int>>();
        var remaining = new Queue<int>();
        int j = 0;
        foreach (var a in sortedA) {
            if (a > sortedB[j].Value) {
                if (!assigned.ContainsKey(sortedB[j].Value))
                    assigned[sortedB[j].Value] = new Queue<int>();
                assigned[sortedB[j].Value].Enqueue(a);
                j++;
            } else {
                remaining.Enqueue(a);
            }
        }
        var result = new int[B.Length];
        for (int i = 0; i < B.Length; i++) {
            if (assigned.ContainsKey(B[i]) && assigned[B[i]].Count > 0) {
                result[i] = assigned[B[i]].Dequeue();
            } else {
                result[i] = remaining.Dequeue();
            }
        }
        return result;
    }
}

#include <bits/stdc++.h>
using namespace std;

// Auto-generated C++ draft from the C# solution. Review containers, LINQ and helper types before submit.
class Solution {
public:
    public vector<int>& AdvantageCount(vector<int>& A, vector<int>& B) {
        var sortedA = A.OrderBy(x => x).ToArray();
        var sortedB = B.Select((x, i) => new { Value = x, Index = i }).OrderBy(x => x.Value).ToArray();
        var assigned = new unordered_map<int, queue<int>>();
        var remaining = new queue<int>();
        int j = 0;
        foreach (var a in sortedA) {
            if (a > sortedB[j].Value) {
                if (!assigned.count(sortedB[j].Value))
                    assigned[sortedB[j].Value] = new queue<int>();
                assigned[sortedB[j].Value].Enqueue(a);
                j++;
            } else {
                remaining.Enqueue(a);
            }
        }
        var result = new int[B.size()];
        for (int i = 0; i < B.size(); i++) {
            if (assigned.count(B[i]) && assigned[B[i]].size() > 0) {
                result[i] = assigned[B[i]].Dequeue();
            } else {
                result[i] = remaining.Dequeue();
            }
        }
        return result;
    }
}

import java.util.*;
import java.math.*;

// Auto-generated Java draft from the C# solution. Review API differences before LeetCode submit.
public class Solution {
    public int[] AdvantageCount(int[] A, int[] B) {
        var sortedA = A.OrderBy(x => x).ToArray();
        var sortedB = B.Select((x, i) => new { Value = x, Index = i }).OrderBy(x => x.Value).ToArray();
        var assigned = new HashMap<int, Queue<int>>();
        var remaining = new LinkedList<int>();
        int j = 0;
        foreach (var a in sortedA) {
            if (a > sortedB[j].Value) {
                if (!assigned.containsKey(sortedB[j].Value))
                    assigned[sortedB[j].Value] = new LinkedList<int>();
                assigned[sortedB[j].Value].Enqueue(a);
                j++;
            } else {
                remaining.Enqueue(a);
            }
        }
        var result = new int[B.length];
        for (int i = 0; i < B.length; i++) {
            if (assigned.containsKey(B[i]) && assigned[B[i]].size() > 0) {
                result[i] = assigned[B[i]].poll();
            } else {
                result[i] = remaining.poll();
            }
        }
        return result;
    }
}

var advantageCount = function(A, B) {
    let sortedA = A.slice().sort((a, b) => a - b);
    let sortedB = B.map((val, idx) => [val, idx]).sort((a, b) => a[0] - b[0]);
    let assigned = {}, remaining = [], j = 0;

    B.forEach(b => assigned[b] = []);

    sortedA.forEach(a => {
        if (a > sortedB[j][0]) {
            assigned[sortedB[j][0]].push(a);
            j++;
        } else {
            remaining.push(a);
        }
    });

    return B.map(b => assigned[b].length ? assigned[b].pop() : remaining.pop());
};

Algorithm

Отсортируйте nums1 и nums2. Для каждой карты a из отсортированного nums1 определите, может ли она побить текущую наименьшую карту b из отсортированного nums2. Если да, добавьте a в assigned[b], если нет, добавьте a в remaining.

После распределения всех карт из nums1, используйте assigned и remaining для построения итогового результата. Для каждой карты b из nums2, если assigned[b] не пуст, добавьте в результат последнюю карту из assigned[b], иначе добавьте последнюю карту из remaining.

Верните итоговый результат.

😎