Transpose Matrix - Practice Coding Problems

Transpose Matrix - Problem

Given a 2D integer array matrix, return the transpose of matrix.

The transpose of a matrix is the matrix flipped over its main diagonal, switching the matrix's row and column indices.

In other words, if matrix[i][j] contains some value, then in the transposed matrix, that same value will be at transpose[j][i].

Input & Output

Example 1 — Basic Rectangle Matrix

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

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

💡 Note: The transpose flips over the main diagonal: element at (0,0)=1 stays, (0,1)=2 moves to (1,0), (0,2)=3 moves to (2,0), etc.

Example 2 — Square Matrix

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

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

💡 Note: In a 2×2 matrix: (0,1) and (1,0) elements swap positions while diagonal elements (0,0) and (1,1) remain in place.

Example 3 — Single Row

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

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

💡 Note: A 1×4 matrix becomes a 4×1 matrix - the row becomes a column.

Constraints

1 ≤ matrix.length ≤ 1000
1 ≤ matrix[i].length ≤ 1000
-10⁹ ≤ matrix[i][j] ≤ 10⁹

Visualization

Tap to expand

Understanding the Visualization

Input Matrix

Original m×n matrix with elements at specific positions

Transpose Operation

Flip over main diagonal - rows become columns

Output Matrix

New n×m matrix with elements at swapped positions

Key Takeaway

🎯 Key Insight: The transpose operation swaps the row and column indices of every element

Asked in

a Amazon 15 M Microsoft 12

The key insight is that transposing a matrix means swapping rows and columns - element at position (i,j) moves to position (j,i). Best approach creates a new matrix with swapped dimensions and copies elements directly. Time: O(m×n), Space: O(m×n)

Common Approaches

Approach	Time	Space	Notes
✓ Direct Transpose	O(m×n)	O(m×n)	Create new matrix with swapped dimensions and copy elements

Direct Transpose — Algorithm Steps

Create new matrix with swapped dimensions
Iterate through original matrix
Copy each element to transposed position

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Matrix

Start with m×n matrix

Create New Matrix

Allocate n×m matrix

Copy Elements

Move element (i,j) to position (j,i)

Code -

solution.c — C

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

int** solution(int** matrix, int matrixSize, int* matrixColSize, int* returnSize, int** returnColumnSizes) {
    if (matrixSize == 0 || matrixColSize[0] == 0) {
        *returnSize = 0;
        return NULL;
    }
    
    int rows = matrixSize;
    int cols = matrixColSize[0];
    
    *returnSize = cols;
    *returnColumnSizes = (int*)malloc(cols * sizeof(int));
    int** transpose = (int**)malloc(cols * sizeof(int*));
    
    for (int i = 0; i < cols; i++) {
        (*returnColumnSizes)[i] = rows;
        transpose[i] = (int*)malloc(rows * sizeof(int));
    }
    
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            transpose[j][i] = matrix[i][j];
        }
    }
    
    return transpose;
}

int main() {
    // Simple parsing for demonstration
    // In real implementation, would need proper JSON parsing
    int rows = 2, cols = 3;
    int** matrix = (int**)malloc(rows * sizeof(int*));
    int* matrixColSize = (int*)malloc(rows * sizeof(int));
    
    for (int i = 0; i < rows; i++) {
        matrix[i] = (int*)malloc(cols * sizeof(int));
        matrixColSize[i] = cols;
    }
    
    // Example: [[1,2,3],[4,5,6]]
    matrix[0][0] = 1; matrix[0][1] = 2; matrix[0][2] = 3;
    matrix[1][0] = 4; matrix[1][1] = 5; matrix[1][2] = 6;
    
    int returnSize;
    int* returnColumnSizes;
    int** result = solution(matrix, rows, matrixColSize, &returnSize, &returnColumnSizes);
    
    // Print result
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("[");
        for (int j = 0; j < returnColumnSizes[i]; j++) {
            printf("%d", result[i][j]);
            if (j < returnColumnSizes[i] - 1) printf(",");
        }
        printf("]");
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

Visit each element once in the m×n matrix

✓ Linear Growth

Space Complexity

O(m×n)

Create new matrix to store the transpose

⚡ Linearithmic Space

28.5K Views

Medium Frequency

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

Constraints

Visualization

Related Problems

Common Approaches

Direct Transpose — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler