##### Welcome to Subscribe On Youtube

Formatted question description: https://leetcode.ca/all/2418.html

# 2418. Sort the People

• Difficulty: Easy.
• Related Topics: .
• Similar Questions: Sort Array by Increasing Frequency.

## Problem

You are given an array of strings names, and an array heights that consists of distinct positive integers. Both arrays are of length n.

For each index i, names[i] and heights[i] denote the name and height of the ith person.

Return names** sorted in descending order by the people’s heights**.

Example 1:

Input: names = ["Mary","John","Emma"], heights = [180,165,170]
Output: ["Mary","Emma","John"]
Explanation: Mary is the tallest, followed by Emma and John.


Example 2:

Input: names = ["Alice","Bob","Bob"], heights = [155,185,150]
Output: ["Bob","Alice","Bob"]
Explanation: The first Bob is the tallest, followed by Alice and the second Bob.


Constraints:

• n == names.length == heights.length

• 1 <= n <= 10^3

• 1 <= names[i].length <= 20

• 1 <= heights[i] <= 10^5

• names[i] consists of lower and upper case English letters.

• All the values of heights are distinct.

## Solution (Java, C++, Python)

• class Solution {
public String[] sortPeople(String[] names, int[] heights) {
int n = heights.length;
int[][] arr = new int[n];
for (int i = 0; i < n; ++i) {
arr[i] = new int[] {heights[i], i};
}
Arrays.sort(arr, (a, b) -> b - a);
String[] ans = new String[n];
for (int i = 0; i < n; ++i) {
ans[i] = names[arr[i]];
}
return ans;
}
}

• class Solution {
public:
vector<string> sortPeople(vector<string>& names, vector<int>& heights) {
int n = heights.size();
vector<pair<int, int>> arr(n);
for (int i = 0; i < n; ++i) {
arr[i] = {-heights[i], i};
}
sort(arr.begin(), arr.end());
vector<string> ans(n);
for (int i = 0; i < n; ++i) {
ans[i] = names[arr[i].second];
}
return ans;
}
};

• class Solution:
def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
idx = list(range(len(heights)))
idx.sort(key=lambda i: -heights[i])
return [names[i] for i in idx]


• func sortPeople(names []string, heights []int) []string {
n := len(heights)
type pair struct{ v, i int }
arr := make([]pair, n)
for i, v := range heights {
arr[i] = pair{v, i}
}
sort.Slice(arr, func(i, j int) bool { return arr[i].v > arr[j].v })
ans := make([]string, n)
for i, v := range arr {
ans[i] = names[v.i]
}
return ans
}

• function sortPeople(names: string[], heights: number[]): string[] {
return names
.map<[string, number]>((s, i) => [s, heights[i]])
.sort((a, b) => b - a)
.map(([v]) => v);
}


• impl Solution {
pub fn sort_people(names: Vec<String>, heights: Vec<i32>) -> Vec<String> {
let mut combine: Vec<(String, i32)> = names.into_iter().zip(heights.into_iter()).collect();
combine.sort_by(|a, b| b.1.cmp(&a.1));
combine.iter().map(|s| s.0.clone()).collect()
}
}



Explain:

nope.

Complexity:

• Time complexity : O(n).
• Space complexity : O(n).