Convert 1D Array Into 2D Array - Practice Coding Problems

Convert 1D Array Into 2D Array - Problem

Given a 1-dimensional integer array called original and two integers m (rows) and n (columns), your task is to reshape the 1D array into a 2D matrix of size m × n.

The transformation follows a simple rule: fill the 2D array row by row using elements from the original array in order. The first n elements form the first row, the next n elements form the second row, and so on.

Important: If it's impossible to create an m × n matrix using all elements from the original array (i.e., when original.length ≠ m × n), return an empty 2D array.

Example: Array [1,2,3,4,5,6] with m=2, n=3 becomes:
[[1,2,3], [4,5,6]]

Input & Output

example_1.py — Basic Transformation

$ Input: original = [1,2,3,4], m = 2, n = 2

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

💡 Note: The original array has 4 elements, and we need a 2×2 matrix (4 cells total). First row gets elements [1,2], second row gets [3,4].

example_2.py — Impossible Case

$ Input: original = [1,2,3], m = 1, n = 2

› Output: []

💡 Note: The original array has 3 elements, but a 1×2 matrix only has 2 cells. Since 3 ≠ 1×2, transformation is impossible.

example_3.py — Single Row

$ Input: original = [1,2,3,4,5,6], m = 1, n = 6

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

💡 Note: All 6 elements fit into a single row with 6 columns, creating a 1×6 matrix.

Visualization

Tap to expand

Understanding the Visualization

Validate Dimensions

Check if total books equals shelf capacity (original.length == m × n)

Create Empty Shelf

Set up the bookshelf with m rows and n columns

Fill Row by Row

Take books from the line in order and fill each shelf row completely

Complete Arrangement

Continue until all books are placed on the shelf

Key Takeaway

🎯 Key Insight: Instead of calculating index mappings for each position, simply iterate through the original array once and fill the 2D matrix row by row sequentially.

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

We visit each cell in the m×n matrix exactly once, performing constant work per cell

✓ Linear Growth

Space Complexity

O(m × n)

We create a new 2D array of size m×n to store the result

⚡ Linearithmic Space

Constraints

1 ≤ original.length ≤ 5 × 10⁴
1 ≤ original[i] ≤ 10⁵
1 ≤ m, n ≤ 4 × 10⁴
Key constraint: Array length must equal m × n for valid transformation

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal approach is to sequentially fill the 2D array row by row using a single loop through the original array. First, check if transformation is possible by verifying original.length == m × n. Then iterate through the original array and place each element at position (index / n, index % n) in the result matrix. This gives us O(m × n) time complexity with minimal overhead.

Common Approaches

Approach	Time	Space	Notes
✓ Position Mapping Approach	O(m × n)	O(m × n)	Calculate the 1D index for each 2D position using mathematical formula

Position Mapping Approach — Algorithm Steps

Check if reshaping is possible (original.length == m * n)
Create a new 2D array with m rows and n columns
For each row i from 0 to m-1
For each column j from 0 to n-1, calculate 1D index = i * n + j
Set result[i][j] = original[index]

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Validity

Verify that original array length equals m × n

Create Matrix

Initialize empty m × n matrix

Map Positions

For each (i,j), calculate index = i × n + j

Fill Values

Set result[i][j] = original[index]

Code -

solution.c — C

int** construct2DArray(int* original, int originalSize, int m, int n, int* returnSize, int** returnColumnSizes) {
    // Check if transformation is possible
    if (originalSize != m * n) {
        *returnSize = 0;
        return NULL;
    }
    
    // Allocate result matrix
    int** result = (int**)malloc(m * sizeof(int*));
    *returnColumnSizes = (int*)malloc(m * sizeof(int));
    
    for (int i = 0; i < m; i++) {
        result[i] = (int*)malloc(n * sizeof(int));
        (*returnColumnSizes)[i] = n;
    }
    
    // Fill matrix using position mapping
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            int index = i * n + j;
            result[i][j] = original[index];
        }
    }
    
    *returnSize = m;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

We visit each cell in the m×n matrix exactly once, performing constant work per cell

✓ Linear Growth

Space Complexity

O(m × n)

We create a new 2D array of size m×n to store the result

⚡ Linearithmic Space

Constraints

1 ≤ original.length ≤ 5 × 10⁴
1 ≤ original[i] ≤ 10⁵
1 ≤ m, n ≤ 4 × 10⁴
Key constraint: Array length must equal m × n for valid transformation

28.4K Views

Medium Frequency

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Position Mapping Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler