Sort the Students by Their Kth Score - Practice Coding Problems

Sort the Students by Their Kth Score - Problem

There is a class with m students and n exams. You are given a 0-indexed m x n integer matrix score, where each row represents one student and score[i][j] denotes the score the i-th student got in the j-th exam.

The matrix score contains distinct integers only.

You are also given an integer k. Sort the students (i.e., the rows of the matrix) by their scores in the k-th (0-indexed) exam from the highest to the lowest.

Return the matrix after sorting it.

Input & Output

Example 1 — Basic Case

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

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

💡 Note: Sort by column k=1 (2nd column): Student scores in column 1 are [6,5,8]. Sorted descending: 8 > 6 > 5, so rows reorder to [[4,8,3,15],[10,6,9,1],[7,5,11,2]]

Example 2 — Sort by First Column

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

› Output: [[5,6],[3,4]]

💡 Note: Sort by column k=0 (1st column): Student scores in column 0 are [3,5]. Sorted descending: 5 > 3, so rows reorder to [[5,6],[3,4]]

Example 3 — Single Student

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

› Output: [[1,2,3]]

💡 Note: Only one student, so the matrix remains unchanged regardless of which column k we sort by

Constraints

m == score.length
n == score[i].length
2 ≤ n ≤ 1000
1 ≤ m ≤ 1000
1 ≤ score[i][j] ≤ 10⁶
score consists of distinct integers
0 ≤ k < n

Visualization

Tap to expand

Understanding the Visualization

Input Matrix

Each row represents a student, each column an exam

Focus on Column k

Extract k-th exam scores to determine sort order

Sort Rows

Reorder entire rows based on k-th column values (highest to lowest)

Key Takeaway

🎯 Key Insight: Sort entire rows as units based on a single column's values, maintaining row integrity while reordering by performance

Asked in

G Google 25 a Amazon 20 M Microsoft 15

The key insight is to sort the entire matrix rows based on values in a specific column k. The optimal approach uses built-in sorting with a custom comparator that compares the k-th element of each row in descending order. Time: O(m log m), Space: O(log m)

Common Approaches

Approach	Time	Space	Notes
✓ Bubble Sort Approach	O(m²)	O(1)	Use bubble sort to compare adjacent rows based on k-th column values
Built-in Sort with Custom Comparator	O(m log m)	O(log m)	Use built-in sorting algorithm with custom comparison function based on k-th column

Bubble Sort Approach — Algorithm Steps

Compare each pair of adjacent rows
Swap if first row's k-th score < second row's k-th score
Repeat until no swaps needed

Visualization

Tap to expand

Step-by-Step Walkthrough

Compare

Compare adjacent rows' k-th scores

Swap

Swap if first score < second score

Result

Rows sorted by k-th column descending

Code -

solution.c — C

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

int** solution(int** score, int scoreSize, int* scoreColSize, int k, int* returnSize, int** returnColumnSizes) {
    *returnSize = scoreSize;
    *returnColumnSizes = (int*)malloc(scoreSize * sizeof(int));
    for (int i = 0; i < scoreSize; i++) {
        (*returnColumnSizes)[i] = scoreColSize[i];
    }
    
    // Bubble sort based on k-th column
    for (int i = 0; i < scoreSize; i++) {
        for (int j = 0; j < scoreSize - 1; j++) {
            // If current row's k-th score < next row's k-th score, swap
            if (score[j][k] < score[j + 1][k]) {
                int* temp = score[j];
                score[j] = score[j + 1];
                score[j + 1] = temp;
                
                int tempSize = (*returnColumnSizes)[j];
                (*returnColumnSizes)[j] = (*returnColumnSizes)[j + 1];
                (*returnColumnSizes)[j + 1] = tempSize;
            }
        }
    }
    return score;
}

int main() {
    // Simple implementation for the matrix parsing
    printf("[[10,6,9,1],[7,5,11,2],[4,8,3,15]]");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m²)

Nested loops: outer loop runs m times, inner loop runs m times for bubble sort

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra variables for swapping, sorting in place

✓ Linear Space

32.5K Views

Medium Frequency

~15 min Avg. Time

890 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

Bubble Sort Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler