Reshape the Matrix - Practice Coding Problems

Reshape the Matrix - Problem

Imagine you have a data transformation challenge similar to what data scientists face daily! You're given a matrix (2D array) and need to reshape it into a different configuration while preserving all the original data in the same order.

Given an m × n matrix mat and two integers r and c, your task is to reshape the matrix into an r × c matrix. The reshaping should follow these rules:

🔄 Same row-traversing order: Fill the new matrix by reading the original matrix row by row, left to right
✅ Validate dimensions: Only reshape if m × n = r × c (same total elements)
❌ Invalid reshape: Return the original matrix unchanged if reshaping is impossible

Example: Transform [[1,2],[3,4]] with r=1, c=4 → [[1,2,3,4]]

Input & Output

example_1.py — Basic Reshape

$ Input: mat = [[1,2],[3,4]], r = 1, c = 4

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

💡 Note: We transform a 2×2 matrix into a 1×4 matrix. Reading the original matrix row by row gives us [1,2,3,4], which becomes a single row in the result.

example_2.py — Invalid Reshape

$ Input: mat = [[1,2],[3,4]], r = 2, c = 4

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

💡 Note: The original matrix has 4 elements (2×2=4), but the target has 8 elements (2×4=8). Since 4≠8, the reshape is impossible, so we return the original matrix unchanged.

example_3.py — Vertical Reshape

$ Input: mat = [[1,2,3,4]], r = 4, c = 1

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

💡 Note: We transform a 1×4 matrix (single row) into a 4×1 matrix (single column). Each element becomes its own row in the result.

Visualization

Tap to expand

Understanding the Visualization

Validate Reshape

Check if total elements match: original m×n must equal target r×c

Calculate Linear Index

For each element at position (i,j), find its sequential position: idx = i×n + j

Map to New Position

Place element at new coordinates: newRow = idx÷c, newCol = idx%c

Build Result

Continue until all elements are repositioned in the new matrix layout

Key Takeaway

🎯 Key Insight: Matrix reshaping is essentially a coordinate transformation problem - convert from one 2D indexing system to another while preserving element order through linear indexing.

Time & Space Complexity

Time Complexity

⏱️

O(m*n)

Single pass through all elements in the matrix

✓ Linear Growth

Space Complexity

O(1)

Only the result matrix is needed, no extra auxiliary space

✓ Linear Space

Constraints

m == mat.length
n == mat[i].length
1 ≤ m, n ≤ 100
1 ≤ mat[i][j] ≤ 1000
1 ≤ r, c ≤ 300
The total number of elements must be preserved

Asked in

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

The optimal approach uses direct index mapping with the mathematical formula: convert 2D coordinates to linear index (idx = i×n + j), then map to new 2D position (newRow = idx÷c, newCol = idx%c). This achieves O(m×n) time and O(1) extra space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Direct Mapping (Optimal)	O(m*n)	O(1)	Use mathematical index conversion to directly map elements from old to new positions
Brute Force (Element by Element Copy)	O(m*n)	O(m*n)	Flatten the matrix to 1D array, then fill the new matrix element by element

One-Pass Direct Mapping (Optimal) — Algorithm Steps

Check if reshaping is possible: m*n must equal r*c
Create new r×c result matrix
For each element in original matrix at (i,j):
Calculate linear index: idx = i*n + j
Map to new position: new_row = idx/c, new_col = idx%c
Place element at new position in result matrix

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Linear Index

Convert 2D position to 1D index: idx = i*n + j

Map to New Position

Convert back to 2D: newRow = idx/c, newCol = idx%c

Place Element

Put element directly in calculated position

Code -

solution.c — C

int** matrixReshape(int** mat, int matSize, int* matColSize, int r, int c, int* returnSize, int** returnColumnSizes) {
    int m = matSize, n = matColSize[0];
    
    // Check if reshape is possible
    if (m * n != r * c) {
        *returnSize = matSize;
        *returnColumnSizes = matColSize;
        return mat;
    }
    
    // Create result matrix
    int** result = (int**)malloc(r * sizeof(int*));
    *returnColumnSizes = (int*)malloc(r * sizeof(int));
    for (int i = 0; i < r; i++) {
        result[i] = (int*)malloc(c * sizeof(int));
        (*returnColumnSizes)[i] = c;
    }
    
    // Direct mapping using index conversion
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            // Calculate linear index
            int idx = i * n + j;
            // Map to new position
            int newRow = idx / c;
            int newCol = idx % c;
            result[newRow][newCol] = mat[i][j];
        }
    }
    
    *returnSize = r;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(m*n)

Single pass through all elements in the matrix

✓ Linear Growth

Space Complexity

O(1)

Only the result matrix is needed, no extra auxiliary space

✓ Linear Space

Constraints

m == mat.length
n == mat[i].length
1 ≤ m, n ≤ 100
1 ≤ mat[i][j] ≤ 1000
1 ≤ r, c ≤ 300
The total number of elements must be preserved

89.5K Views

Medium Frequency

~15 min Avg. Time

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

One-Pass Direct Mapping (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler