Reshape the Matrix

Reshape the Matrix - Problem

In MATLAB, there is a handy function called reshape which can reshape an m × n matrix into a new one with a different size r × c keeping its original data.

You are given an m × n matrix mat and two integers r and c representing the number of rows and columns of the wanted reshaped matrix.

The reshaped matrix should be filled with all the elements of the original matrix in the same row-traversing order as they were.

If the reshape operation with given parameters is possible and legal, output the new reshaped matrix; Otherwise, output the original matrix.

Input & Output

Example 1 — Basic Reshape

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

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

💡 Note: The original 2×2 matrix has 4 elements. We reshape it to 1×4 by reading elements row by row: 1,2,3,4 and placing them in a single row.

Example 2 — 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 target has 8 elements (2×4=8). Since reshape is impossible, return the original matrix.

Example 3 — Square to Rectangle

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

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

💡 Note: Convert 2×3 matrix to 3×2 matrix. Reading row by row: 1,2,3,4,5,6 then fill new matrix: [[1,2],[3,4],[5,6]].

Constraints

m == mat.length
n == mat[i].length
1 ≤ m, n ≤ 100
1 ≤ r, c ≤ 300
-10⁴ ≤ mat[i][j] ≤ 10⁴

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to check if the total number of elements remains the same (m×n = r×c) before reshaping. Best approach is direct index mapping to avoid extra space. Time: O(r×c), Space: O(1).

Common Approaches

✓ Brute Force - Flatten and Rebuild

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

First convert the 2D matrix into a flat list by reading row by row. Then create a new matrix with the target dimensions and fill it from the flat list.

Direct Mapping with Index Conversion

⏱️ Time: O(r×c) Space: O(1)

Instead of creating intermediate arrays, use mathematical formulas to convert between 2D coordinates and 1D index, then directly place elements in the result matrix.

Brute Force - Flatten and Rebuild — Algorithm Steps

Check if reshape is valid (m×n = r×c)
Flatten original matrix into 1D array
Create new r×c matrix and fill from flattened array

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Validity

Verify m×n = r×c

Flatten Matrix

Convert 2D to 1D array

Rebuild Matrix

Create new matrix with target dimensions

Code -

solution.c — C

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

int** solution(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;
    }
    
    // Flatten the matrix
    int* flat = (int*)malloc(m * n * sizeof(int));
    int index = 0;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            flat[index++] = mat[i][j];
        }
    }
    
    // Create new matrix
    int** result = (int**)malloc(r * sizeof(int*));
    *returnColumnSizes = (int*)malloc(r * sizeof(int));
    *returnSize = r;
    
    index = 0;
    for (int i = 0; i < r; i++) {
        result[i] = (int*)malloc(c * sizeof(int));
        (*returnColumnSizes)[i] = c;
        for (int j = 0; j < c; j++) {
            result[i][j] = flat[index++];
        }
    }
    
    free(flat);
    return result;
}

int main() {
    // Simple input parsing for demo
    int mat[2][2] = {{1, 2}, {3, 4}};
    int* matRows[2];
    matRows[0] = mat[0];
    matRows[1] = mat[1];
    int matColSize[2] = {2, 2};
    
    int r = 1, c = 4;
    int returnSize;
    int* returnColumnSizes;
    
    int** result = solution(matRows, 2, matColSize, r, c, &returnSize, &returnColumnSizes);
    
    // Print result in JSON format
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("[");
        for (int j = 0; j < returnColumnSizes[i]; j++) {
            if (j > 0) printf(",");
            printf("%d", result[i][j]);
        }
        printf("]");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

One pass to flatten the matrix and one pass to rebuild it

✓ Linear Growth

Space Complexity

O(m×n)

Extra space for flattened array plus the result matrix

⚡ Linearithmic Space

186.3K Views

Medium Frequency

~15 min Avg. Time

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

Brute Force - Flatten and Rebuild — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler