Problème
Le Join de LINQ associe les éléments de deux séquences par une clé commune, comme une jointure en base de données. Ici, les clients sont associés à leurs commandes par identifiant client.
Le client i a l'identifiant customer_ids[i] et le nom customer_names[i]. Chaque commande est [customer_id, amount].
Joignez les deux : pour chaque client ayant au moins une commande, additionnez les montants de ses commandes. Les clients sans commande sont exclus, et les commandes dont l'identifiant est inconnu sont ignorées.
Implémentez join_customers_orders(customer_ids, customer_names, orders).
Entrée
customer_ids, customer_names: Les clients (identifiants distincts).
orders: Des paires [customer_id, amount].
Sortie
Renvoyez "<name>:<total>" pour chaque client ayant des commandes, triés par total décroissant, puis par nom (ordre ordinal) à total égal.
Contraintes
1 ≤ nombre de clients ≤ 10,000
0 ≤ nombre de commandes ≤ 100,000 ; 1 ≤ amount ≤ 10^6
Exemples
Entrée :
orders = [
[1, 50],
[2, 30],
[1, 20]
]
customer_ids = [1, 2, 3]
customer_names = ["Ada", "Lin", "Bo"]
Sortie attendue :
expected = ["Ada:70", "Lin:30"]Entrée :
std::vector<std::vector<long long>> orders = {
{1, 50},
{2, 30},
{1, 20}
};
std::vector<long long> customer_ids = {1, 2, 3};
std::vector<std::string> customer_names = {"Ada", "Lin", "Bo"};
Sortie attendue :
std::vector<std::string> expected = {"Ada:70", "Lin:30"};Entrée :
long[][] orders = new long[][] {
new long[] {1, 50},
new long[] {2, 30},
new long[] {1, 20}
};
long[] customer_ids = new long[] {1, 2, 3};
string[] customer_names = new string[] {"Ada", "Lin", "Bo"};
Sortie attendue :
string[] expected = new string[] {"Ada:70", "Lin:30"};Explication
Ada a deux commandes (50 + 20 = 70) et Lin une (30) ; Bo n'en a aucune et est exclu : ["Ada:70", "Lin:30"].
Entrée :
orders = [
[8, 40],
[7, 40],
[9, 99]
]
customer_ids = [7, 8]
customer_names = ["Zoe", "Max"]
Sortie attendue :
expected = ["Max:40", "Zoe:40"]Entrée :
std::vector<std::vector<long long>> orders = {
{8, 40},
{7, 40},
{9, 99}
};
std::vector<long long> customer_ids = {7, 8};
std::vector<std::string> customer_names = {"Zoe", "Max"};
Sortie attendue :
std::vector<std::string> expected = {"Max:40", "Zoe:40"};Entrée :
long[][] orders = new long[][] {
new long[] {8, 40},
new long[] {7, 40},
new long[] {9, 99}
};
long[] customer_ids = new long[] {7, 8};
string[] customer_names = new string[] {"Zoe", "Max"};
Sortie attendue :
string[] expected = new string[] {"Max:40", "Zoe:40"};Explication
Les deux totalisent 40, ils sont donc triés par nom ; la commande de l'identifiant inconnu 9 est ignorée : ["Max:40", "Zoe:40"].
Comment l'aborder
Essayez d'abord seul, puis ouvrez les indices un par un.
Indice 1
Additionnez d'abord les montants des commandes par identifiant client.
Indice 2
Parcourez ensuite les clients et gardez ceux qui ont un total.
Indice 3
Triez par total décroissant, puis par nom en ordre ordinal.
Complexité attendue
temps O(n log n), espace supplémentaire O(n)
Références
Ce défi a été adapté pour CodeUtility. Suivez l'énoncé et les contraintes ci-dessus.