Sort Matrix by Diagonals - Practice Coding Problems

Sort Matrix by Diagonals - Problem

You are given an n × n square matrix of integers. Your task is to sort specific diagonals in different orders to create a beautifully organized pattern:

Bottom-left triangle diagonals (including the main diagonal): Sort in non-increasing order (largest to smallest)
Top-right triangle diagonals: Sort in non-decreasing order (smallest to largest)

Think of it as creating a mountain peak along the main diagonal - values decrease as you go down-left, and increase as you go up-right!

Example: In a 3×3 matrix, diagonal [1,5,9] becomes [9,5,1] (decreasing), while diagonal [3,7] becomes [3,7] (increasing).

Input & Output

example_1.py — Basic 3x3 Matrix

$ Input: grid = [[3,1,2],[5,7,4],[8,6,9]]

› Output: [[9,1,2],[6,7,4],[5,5,3]]

💡 Note: Main diagonal [3,7,9] becomes [9,7,3] (decreasing). Diagonal [5,6] becomes [6,5] (decreasing). Top-right diagonals [1], [2,4] remain [1], [2,4] (increasing).

example_2.py — 4x4 Matrix

$ Input: grid = [[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]]

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

💡 Note: Bottom-left diagonals sorted in decreasing order: [1,6,11,16]→[16,11,6,1], [5,10,15]→[15,10,5], etc. Top-right diagonals sorted in increasing order.

example_3.py — Single Element

$ Input: grid = [[42]]

› Output: [[42]]

💡 Note: Single element matrix remains unchanged as there's only the main diagonal with one element.

Constraints

1 ≤ n ≤ 1000
1 ≤ grid[i][j] ≤ 10⁵
The matrix is always square (n × n)
All elements in the matrix are positive integers

Visualization

Tap to expand

Understanding the Visualization

Identify Triangles

Split matrix into bottom-left (including main diagonal) and top-right triangles

Classify Diagonals

Use mathematical formulas: i-j for bottom-left, i+j for top-right

Sort by Rules

Bottom-left diagonals: decreasing order, Top-right diagonals: increasing order

Reconstruct Matrix

Place sorted elements back creating the mountain peak pattern

Key Takeaway

🎯 Key Insight: By using mathematical properties (i-j and i+j) to identify diagonals, we can efficiently sort the matrix to create a beautiful mountain peak pattern where values decrease going down-left and increase going up-right.

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal approach uses hash maps to efficiently group diagonal elements by their mathematical properties: i-j for bottom-left triangles and i+j for top-right triangles. This allows us to collect, sort, and redistribute elements in O(n² log n) time with a single pass for classification.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Hash Map Approach	O(n² log n)	O(n²)	Use hash maps to group diagonal elements efficiently in one pass
Brute Force (Extract and Sort Each Diagonal)	O(n³)	O(n)	Extract each diagonal individually, sort it, and put values back

Optimized Hash Map Approach — Algorithm Steps

Create hash maps to group elements by diagonal (i-j for bottom-left, i+j for top-right)
In one pass through the matrix, classify each element into its diagonal group
Sort each diagonal group according to the required order
Place sorted elements back into the matrix using the same classification logic
Return the modified matrix

Visualization

Tap to expand

Step-by-Step Walkthrough

Classify Elements

Use i-j for bottom-left, i+j for top-right triangles

Group by Hash

Store elements in hash maps by diagonal identifier

Sort Groups

Sort each diagonal group in required order

Reconstruct Matrix

Place sorted elements back using same classification

Code -

solution.c — C

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

#define MAX_N 1000

int compare_desc(const void *a, const void *b) {
    return (*(int*)b - *(int*)a);
}

int compare_asc(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

void sortMatrixByDiagonals(int** grid, int n) {
    // Arrays to store diagonal elements
    int bottomLeftDiagonals[MAX_N][MAX_N];
    int topRightDiagonals[MAX_N][MAX_N];
    int bottomLeftCounts[MAX_N] = {0};
    int topRightCounts[MAX_N] = {0};
    
    // Single pass to classify all elements
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (i >= j) { // Bottom-left triangle
                int key = i - j;
                bottomLeftDiagonals[key][bottomLeftCounts[key]++] = grid[i][j];
            } else { // Top-right triangle
                int key = i + j;
                topRightDiagonals[key][topRightCounts[key]++] = grid[i][j];
            }
        }
    }
    
    // Sort each diagonal group
    for (int i = 0; i < n; i++) {
        if (bottomLeftCounts[i] > 0) {
            qsort(bottomLeftDiagonals[i], bottomLeftCounts[i], sizeof(int), compare_desc);
        }
        if (topRightCounts[i] > 0) {
            qsort(topRightDiagonals[i], topRightCounts[i], sizeof(int), compare_asc);
        }
    }
    
    // Indices for placing back elements
    int bottomLeftIndices[MAX_N] = {0};
    int topRightIndices[MAX_N] = {0};
    
    // Place sorted elements back
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (i >= j) {
                int key = i - j;
                grid[i][j] = bottomLeftDiagonals[key][bottomLeftIndices[key]++];
            } else {
                int key = i + j;
                grid[i][j] = topRightDiagonals[key][topRightIndices[key]++];
            }
        }
    }
}

int main() {
    int n;
    scanf("%d", &n);
    
    int** grid = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        grid[i] = (int*)malloc(n * sizeof(int));
        for (int j = 0; j < n; j++) {
            scanf("%d", &grid[i][j]);
        }
    }
    
    sortMatrixByDiagonals(grid, n);
    
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            printf("%d ", grid[i][j]);
        }
        printf("\n");
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² log n)

We visit each cell once O(n²), and sorting all diagonals takes O(n² log n) total since each element is sorted once

⚠ Quadratic Growth

Space Complexity

O(n²)

Hash maps store all matrix elements temporarily, requiring O(n²) space

⚠ Quadratic Space

42.3K Views

Medium Frequency

~15 min Avg. Time

1.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

Optimized Hash Map Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler