Sort the Students by Their Kth Score

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

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

✓ Bubble Sort Approach

⏱️ Time: O(m²) Space: O(1)

Compare adjacent student rows and swap them if the first student's k-th exam score is lower than the second student's k-th exam score. Repeat until no more swaps are needed.

Built-in Sort with Custom Comparator

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

Leverage the language's built-in sorting function with a custom comparator that compares rows based on their k-th column values. This uses efficient algorithms like quicksort or mergesort internally.

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>

static int score[1000][1000];
static int scoreSize = 0;
static int scoreColSize[1000];

void solution(int k) {
    // 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]) {
                // Swap rows
                for (int col = 0; col < scoreColSize[j]; col++) {
                    int temp = score[j][col];
                    score[j][col] = score[j + 1][col];
                    score[j + 1][col] = temp;
                }
                // Swap column sizes
                int tempSize = scoreColSize[j];
                scoreColSize[j] = scoreColSize[j + 1];
                scoreColSize[j + 1] = tempSize;
            }
        }
    }
}

int main() {
    char line[10000];
    
    // Read first line (JSON-like array)
    fgets(line, sizeof(line), stdin);
    
    // Parse the 2D array manually
    char *ptr = line;
    scoreSize = 0;
    
    // Skip initial '['
    while (*ptr && *ptr != '[') ptr++;
    ptr++;
    
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            // Start of inner array
            ptr++;
            scoreColSize[scoreSize] = 0;
            
            while (*ptr && *ptr != ']') {
                if (*ptr >= '0' && *ptr <= '9') {
                    // Parse number
                    int num = 0;
                    while (*ptr >= '0' && *ptr <= '9') {
                        num = num * 10 + (*ptr - '0');
                        ptr++;
                    }
                    score[scoreSize][scoreColSize[scoreSize]] = num;
                    scoreColSize[scoreSize]++;
                } else {
                    ptr++;
                }
            }
            
            if (*ptr == ']') ptr++; // Skip ']'
            scoreSize++;
        } else {
            ptr++;
        }
    }
    
    // Read k
    int k;
    scanf("%d", &k);
    
    // Call solution
    solution(k);
    
    // Print result in JSON format
    printf("[");
    for (int i = 0; i < scoreSize; i++) {
        if (i > 0) printf(",");
        printf("[");
        for (int j = 0; j < scoreColSize[i]; j++) {
            if (j > 0) printf(",");
            printf("%d", score[i][j]);
        }
        printf("]");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m²)

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

⚡ Linearithmic

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