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)

• Java
• C++
• Python
• Go
• TypeScript
• RenderScript

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

All Problems

All Solutions