Sort the People - Practice Coding Problems

Sort the People - Problem

Sort the People

Imagine you're organizing a lineup for a group photo! You have a list of people's names and their corresponding heights, and you need to arrange them in descending order by height (tallest to shortest).

You are given:
• An array of strings names where each element is a person's name
• An array of integers heights where each element is the corresponding person's height
• Both arrays have the same length n
• All heights are distinct positive integers

Goal: Return the names array sorted in descending order by the people's heights.

Example: If we have names = ["Mary", "John", "Emma"] and heights = [180, 165, 170], the result should be ["Mary", "Emma", "John"] because Mary (180cm) is tallest, then Emma (170cm), then John (165cm).

Input & Output

example_1.py — Basic Case

$ Input: names = ["Mary", "John", "Emma"], heights = [180, 165, 170]

› Output: ["Mary", "Emma", "John"]

💡 Note: Mary is tallest (180cm), then Emma (170cm), then John (165cm). Result is sorted in descending order by height.

example_2.py — Single Person

$ Input: names = ["Alice"], heights = [155]

› Output: ["Alice"]

💡 Note: With only one person, the result is just that person's name.

example_3.py — Already Sorted

$ Input: names = ["Tom", "Jerry", "Mickey"], heights = [190, 180, 170]

› Output: ["Tom", "Jerry", "Mickey"]

💡 Note: The names are already in correct order since heights are already in descending order.

Constraints

n == names.length == heights.length
1 ≤ n ≤ 10³
1 ≤ names[i].length ≤ 20
1 ≤ heights[i] ≤ 10⁵
names[i] consists of lower and upper case English letters
All heights[i] are distinct

Visualization

Tap to expand

Understanding the Visualization

Gather People

Collect all people with their names and heights

Create Pairs

Pair each person's name with their height

Sort by Height

Arrange pairs from tallest to shortest

Final Lineup

Extract names in the correct order

Key Takeaway

🎯 Key Insight: Pairing related data together (height with name) makes sorting intuitive and lets us leverage efficient built-in sorting algorithms. This approach is both optimal and highly readable!

Asked in

a Amazon 15 G Google 12 ⊞ Microsoft 8 f Meta 6

The optimal solution uses the pair sorting approach with O(n log n) time complexity. Create (height, name) pairs, sort by height in descending order, then extract the names. This leverages efficient built-in sorting algorithms and is the most intuitive and readable approach.

Common Approaches

Approach	Time	Space	Notes
✓ Direct Pair Sorting (Optimal)	O(n log n)	O(n)	Create (height, name) pairs and sort directly in one pass
Brute Force (Selection Sort)	O(n²)	O(n)	Manually find the tallest remaining person for each position
Two-Pass with Indices	O(n log n)	O(n)	Create index array, sort by heights, then build result

Direct Pair Sorting (Optimal) — Algorithm Steps

Create pairs of (height, name) for each person
Sort pairs by height in descending order using built-in sort
Extract names from sorted pairs to form the result

Visualization

Tap to expand

Step-by-Step Walkthrough

Create Pairs

Combine each height with corresponding name

Sort Pairs

Sort by height in descending order

Extract Names

Pull out names from sorted pairs

Code -

solution.c — C

typedef struct {
    int height;
    char* name;
} Person;

int compare(const void* a, const void* b) {
    Person* pa = (Person*)a;
    Person* pb = (Person*)b;
    return pb->height - pa->height; // descending order
}

char** sortPeople(char** names, int namesSize, int* heights, int heightsSize, int* returnSize) {
    *returnSize = namesSize;
    
    // Create array of Person structs
    Person* people = (Person*)malloc(namesSize * sizeof(Person));
    for (int i = 0; i < namesSize; i++) {
        people[i].height = heights[i];
        people[i].name = names[i];
    }
    
    // Sort by height descending
    qsort(people, namesSize, sizeof(Person), compare);
    
    // Extract names from sorted pairs
    char** result = (char**)malloc(namesSize * sizeof(char*));
    for (int i = 0; i < namesSize; i++) {
        int len = strlen(people[i].name);
        result[i] = (char*)malloc((len + 1) * sizeof(char));
        strcpy(result[i], people[i].name);
    }
    
    free(people);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Dominated by the built-in sorting algorithm (typically quicksort or mergesort)

⚡ Linearithmic

Space Complexity

O(n)

Space for creating pairs and result array

⚡ Linearithmic Space

125.0K Views

Medium Frequency

~8 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Direct Pair Sorting (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler