Transpose Matrix - Practice Coding Problems

Transpose Matrix - Problem

Given a 2D integer array matrix, return the transpose of the matrix. The transpose of a matrix is created by flipping the matrix over its main diagonal, which means switching the matrix's row and column indices.

In simpler terms, if you have an element at position [i][j] in the original matrix, it will be moved to position [j][i] in the transposed matrix. This operation effectively converts rows into columns and columns into rows.

Goal: Transform the input matrix by swapping rows and columns.
Input: A 2D integer array representing a matrix
Output: A new 2D array representing the transposed matrix

Input & Output

example_1.py — Basic 2x3 Matrix

$ Input: matrix = [[1,2,3],[4,5,6]]

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

💡 Note: The first row [1,2,3] becomes the first column [1,4], and the second row [4,5,6] becomes the second column. Element at [0][0]=1 moves to [0][0]=1, element at [0][1]=2 moves to [1][0]=2, etc.

example_2.py — Square Matrix

$ Input: matrix = [[1,2],[3,4]]

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

💡 Note: In a square matrix, the transpose flips elements across the main diagonal. Element [0][1]=2 swaps with element [1][0]=3.

example_3.py — Single Row Matrix

$ Input: matrix = [[1,2,3,4]]

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

💡 Note: A single row matrix becomes a single column matrix. Each element becomes its own row in the result.

Visualization

Tap to expand

Understanding the Visualization

Identify Dimensions

Original matrix is m×n, result will be n×m

Create Result Matrix

Initialize new matrix with swapped dimensions

Map Coordinates

Element at [i][j] moves to [j][i]

Copy All Elements

Systematically copy each element to its new position

Key Takeaway

🎯 Key Insight: Matrix transpose is simply a coordinate transformation where [i][j] → [j][i]. The algorithm is optimal because every element must be copied exactly once.

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

We need to visit each element exactly once, where m and n are the dimensions of the matrix

✓ Linear Growth

Space Complexity

O(m×n)

We need to create a new matrix to store the transposed result

⚡ Linearithmic Space

Constraints

m == matrix.length
n == matrix[i].length
1 ≤ m, n ≤ 1000
-10⁹ ≤ matrix[i][j] ≤ 10⁹

Asked in

G Google 25 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The transpose operation is a fundamental matrix transformation that swaps rows and columns. The optimal approach creates a new matrix with swapped dimensions and copies each element from position [i][j] to [j][i]. This requires O(m×n) time and space complexity, which is optimal since we must visit every element exactly once.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(m×n)	O(m×n)	Create a new matrix and copy elements with swapped indices

Brute Force (Nested Loops) — Algorithm Steps

Determine the dimensions of the original matrix (m rows, n columns)
Create a new matrix with swapped dimensions (n rows, m columns)
Iterate through each element in the original matrix using nested loops
For each element at position [i][j], place it at position [j][i] in the new matrix
Return the transposed matrix

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Matrix

Start with the original m×n matrix

Create Result Matrix

Create new n×m matrix with swapped dimensions

Copy Elements

Copy each element [i][j] to position [j][i]

Final Result

Complete transposed matrix

Code -

solution.c — C

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

int** transpose(int** matrix, int matrixSize, int* matrixColSize, int* returnSize, int** returnColumnSizes) {
    int m = matrixSize;
    int n = matrixColSize[0];
    
    *returnSize = n;
    *returnColumnSizes = (int*)malloc(n * sizeof(int));
    int** result = (int**)malloc(n * sizeof(int*));
    
    for (int i = 0; i < n; i++) {
        (*returnColumnSizes)[i] = m;
        result[i] = (int*)malloc(m * sizeof(int));
    }
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            result[j][i] = matrix[i][j];
        }
    }
    
    return result;
}

int main() {
    // Example usage
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

We need to visit each element exactly once, where m and n are the dimensions of the matrix

✓ Linear Growth

Space Complexity

O(m×n)

We need to create a new matrix to store the transposed result

⚡ Linearithmic Space

Constraints

m == matrix.length
n == matrix[i].length
1 ≤ m, n ≤ 1000
-10⁹ ≤ matrix[i][j] ≤ 10⁹

78.0K Views

Medium Frequency

~8 min Avg. Time

2.4K 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

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler