Sort the People

Sort the People - 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 i-th person.

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

Input & Output

Example 1 — Basic Sorting

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

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

💡 Note: Mary is tallest (180), Emma is second (170), John is shortest (165). Sorted in descending order by height.

Example 2 — Different Names

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

› Output: ["Bob","Alice","Bob"]

💡 Note: Bob (185) is tallest, Alice (155) is middle, Bob (150) is shortest. Names can repeat but heights are distinct.

Example 3 — Two People

$ Input: names = ["IEO","Sgizfdfrims"], heights = [165,170]

› Output: ["Sgizfdfrims","IEO"]

💡 Note: Sgizfdfrims (170) is taller than IEO (165), so comes first in descending order.

Constraints

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

Visualization

Tap to expand

Asked in

a Amazon 15 M Microsoft 12 G Google 8

The key insight is to pair names with their corresponding heights, sort by height in descending order, then extract the names. The optimal approach uses built-in sort with custom comparator. Time: O(n log n), Space: O(n)

Common Approaches

✓ Brute Force Bubble Sort

⏱️ Time: O(n²) Space: O(n)

Create pairs of names and heights, then use bubble sort to arrange them by height in descending order. Finally extract the sorted names.

Direct Pair Sorting

⏱️ Time: O(n log n) Space: O(n)

Create pairs of (name, height), sort them using built-in sort with custom comparator that compares heights in descending order, then extract names from sorted pairs.

Sort with Index Mapping

⏱️ Time: O(n log n) Space: O(n)

Create an array of indices, sort these indices based on corresponding heights in descending order, then use sorted indices to extract names in the correct order.

Brute Force Bubble Sort — Algorithm Steps

Step 1: Create pairs of (name, height)
Step 2: Use bubble sort to sort pairs by height descending
Step 3: Extract names from sorted pairs

Visualization

Tap to expand

Step-by-Step Walkthrough

Create Pairs

Combine names and heights into pairs

Bubble Sort

Compare adjacent pairs and swap if needed

Extract Names

Return sorted names from pairs

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX 1000
#define MAX_NAME 256

typedef struct {
    char name[MAX_NAME];
    int height;
} Pair;

void trim(char *str) {
    // Trim leading spaces and quotes
    while (*str == ' ' || *str == '"') {
        memmove(str, str + 1, strlen(str));
    }

    // Trim trailing spaces and quotes
    int len = strlen(str);
    while (len > 0 && (str[len - 1] == ' ' || str[len - 1] == '"')) {
        str[len - 1] = '\0';
        len--;
    }
}

char** solution(char names[][MAX_NAME], int heights[], int n) {
    Pair pairs[MAX];

    // Create pairs
    for (int i = 0; i < n; i++) {
        strcpy(pairs[i].name, names[i]);
        pairs[i].height = heights[i];
    }

    // Bubble sort (descending by height)
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (pairs[j].height < pairs[j + 1].height) {
                Pair temp = pairs[j];
                pairs[j] = pairs[j + 1];
                pairs[j + 1] = temp;
            }
        }
    }

    // Allocate result array
    char **result = malloc(n * sizeof(char*));
    for (int i = 0; i < n; i++) {
        result[i] = malloc(MAX_NAME);
        strcpy(result[i], pairs[i].name);
    }

    return result;
}

int main() {
    char line[MAX];
    char names[MAX][MAX_NAME];
    int heights[MAX];
    int n = 0;

    // Read names line
    if (fgets(line, sizeof(line), stdin) == NULL) return 0;

    // Remove newline
    line[strcspn(line, "\n")] = '\0';

    // Remove brackets
    memmove(line, line + 1, strlen(line));
    line[strlen(line) - 1] = '\0';

    // Parse names
    char *token = strtok(line, ",");
    while (token != NULL) {
        trim(token);
        strcpy(names[n++], token);
        token = strtok(NULL, ",");
    }

    // Read heights line
    if (fgets(line, sizeof(line), stdin) == NULL) return 0;
    line[strcspn(line, "\n")] = '\0';

    memmove(line, line + 1, strlen(line));
    line[strlen(line) - 1] = '\0';

    // Parse heights
    int i = 0;
    token = strtok(line, ",");
    while (token != NULL) {
        heights[i++] = atoi(token);
        token = strtok(NULL, ",");
    }

    // Solve
    char **result = solution(names, heights, n);

    // Print result
    printf("[");
    for (int i = 0; i < n; i++) {
        printf("\"%s\"", result[i]);
        if (i < n - 1) printf(",");
        free(result[i]);
    }
    free(result);
    printf("]\n");

    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Bubble sort requires nested loops with n×n comparisons

⚡ Linearithmic

Space Complexity

O(n)

Extra array to store name-height pairs

⚡ Linearithmic Space

25.0K Views

Medium Frequency

~5 min Avg. Time

892 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

Brute Force Bubble Sort — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler