Transpose Matrix

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

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

✓ Direct Transpose

⏱️ Time: O(m×n) Space: O(m×n)

Create a new matrix with dimensions swapped (rows become columns, columns become rows), then iterate through the original matrix and place each element at its transposed position.

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() {
    char line[10000];
    if (!fgets(line, sizeof(line), stdin)) {
        return 1;
    }
    
    // Simple JSON parsing for [[...],[...]] format
    int rows = 0, maxCols = 0;
    
    // Count rows by counting '],' patterns + 1
    char* ptr = line;
    while ((ptr = strstr(ptr, "],")) != NULL) {
        rows++;
        ptr += 2;
    }
    if (strchr(line, '[')) rows++; // Last row
    
    int** matrix = (int**)malloc(rows * sizeof(int*));
    int* matrixColSize = (int*)malloc(rows * sizeof(int));
    
    // Parse each row
    ptr = strchr(line, '[') + 1; // Skip first [
    for (int i = 0; i < rows; i++) {
        ptr = strchr(ptr, '[') + 1; // Find row start
        char* end = strchr(ptr, ']');
        
        // Count numbers in this row
        int cols = 0;
        char* numPtr = ptr;
        while (numPtr < end) {
            if (*numPtr == ',' || numPtr == ptr) cols++;
            numPtr++;
        }
        if (cols > 0 && ptr < end) cols = cols; else cols = 1;
        
        matrixColSize[i] = cols;
        if (cols > maxCols) maxCols = cols;
        matrix[i] = (int*)malloc(cols * sizeof(int));
        
        // Parse numbers
        numPtr = ptr;
        for (int j = 0; j < cols; j++) {
            matrix[i][j] = atoi(numPtr);
            numPtr = strchr(numPtr, ',');
            if (numPtr) numPtr++;
            else break;
        }
        
        ptr = end + 1;
    }
    
    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