Sort the Students by Their Kth Score - Practice Coding Problems

Sort the Students by Their Kth Score - Problem

Imagine you're a teacher managing exam results for your class. You have m students who took n different exams, and you want to rank them based on their performance in one specific exam.

You're given a score matrix where each row represents a student and score[i][j] is the score that student i got on exam j. All scores are unique integers.

Given an integer k, you need to sort the students (rearrange the rows) based on their scores in the k-th exam from highest to lowest.

Goal: Return the matrix with rows sorted by the k-th column in descending order.

Input & Output

example_1.py — Basic Case

$ Input: score = [[10,6,9,1],[7,5,11,2],[4,8,3,15]], k = 2

› Output: [[7,5,11,2],[10,6,9,1],[4,8,3,15]]

💡 Note: Sorting by k=2 (3rd exam): scores are [9,11,3]. Student with score 11 goes first, then 9, then 3.

example_2.py — Single Student

$ Input: score = [[3,4]], k = 0

› Output: [[3,4]]

💡 Note: With only one student, the matrix remains unchanged regardless of which exam we sort by.

example_3.py — Already Sorted

$ Input: score = [[5,4,3],[2,1,0]], k = 0

› Output: [[5,4,3],[2,1,0]]

💡 Note: Students are already sorted by exam 0 in descending order (5 > 2), so no change needed.

Visualization

Tap to expand

Understanding the Visualization

Identify Target Column

Focus on the k-th exam column that determines the ranking

Compare Scores

Use custom comparator to compare students by their k-th exam score

Rearrange Rows

Sort the entire rows (students) based on k-th column values

Final Ranking

Students are now ordered from highest to lowest k-th exam score

Key Takeaway

🎯 Key Insight: We don't need to sort individual elements - we sort entire rows (students) based on one column (exam score), treating each student as a single unit with a comparison key.

Time & Space Complexity

Time Complexity

⏱️

O(m log m)

Built-in sorting algorithms are typically O(m log m) where m is number of students

⚡ Linearithmic

Space Complexity

O(1) to O(m)

Space complexity depends on sorting algorithm used (QuickSort is O(log m), MergeSort is O(m))

✓ Linear Space

Constraints

m == score.length
n == score[i].length
1 ≤ m, n ≤ 250
1 ≤ score[i][j] ≤ 10⁵
score consists of distinct integers
0 ≤ k < n

Asked in

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

The optimal approach uses built-in sorting with a custom comparator that compares rows based on the k-th column values in descending order. This achieves O(m log m) time complexity by leveraging highly optimized sorting algorithms, making it much more efficient than the O(m²) brute force approach.

Common Approaches

Approach	Time	Space	Notes
✓ Built-in Sorting (Optimal)	O(m log m)	O(1) to O(m)	Use optimized built-in sort with custom comparator
Brute Force (Selection Sort)	O(m²)	O(1)	Manually find the student with highest k-th score in each iteration

Built-in Sorting (Optimal) — Algorithm Steps

Define a custom comparator function that compares two rows based on their k-th column
Set the comparator to sort in descending order (higher scores first)
Apply the built-in sort function to the matrix using this comparator
Return the sorted matrix

Visualization

Tap to expand

Step-by-Step Walkthrough

Define Comparator

Create function to compare rows by k-th column

Apply Sort

Built-in algorithm efficiently sorts using comparator

Result

Matrix sorted by k-th column in descending order

Code -

solution.c — C

#include <stdlib.h>

int k_global; // Global variable for comparator

int compare(const void *a, const void *b) {
    int *row1 = *(int **)a;
    int *row2 = *(int **)b;
    return row2[k_global] - row1[k_global]; // Descending order
}

int** sortTheStudents(int** score, int scoreSize, int* scoreColSize, int k, int* returnSize, int** returnColumnSizes) {
    *returnSize = scoreSize;
    *returnColumnSizes = scoreColSize;
    k_global = k;
    
    qsort(score, scoreSize, sizeof(int*), compare);
    return score;
}

Time & Space Complexity

Time Complexity

⏱️

O(m log m)

Built-in sorting algorithms are typically O(m log m) where m is number of students

⚡ Linearithmic

Space Complexity

O(1) to O(m)

Space complexity depends on sorting algorithm used (QuickSort is O(log m), MergeSort is O(m))

✓ Linear Space

Constraints

m == score.length
n == score[i].length
1 ≤ m, n ≤ 250
1 ≤ score[i][j] ≤ 10⁵
score consists of distinct integers
0 ≤ k < n

24.7K Views

Medium Frequency

~8 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Built-in Sorting (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler