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

Convert 1D Array Into 2D Array - Problem

You are given a 0-indexed 1-dimensional (1D) integer array original, and two integers, m and n. You are tasked with creating a 2-dimensional (2D) array with m rows and n columns using all the elements from original.

The elements from indices 0 to n - 1 (inclusive) of original should form the first row of the constructed 2D array, the elements from indices n to 2 * n - 1 (inclusive) should form the second row of the constructed 2D array, and so on.

Return an m x n 2D array constructed according to the above procedure, or an empty 2D array if it is impossible.

Input & Output

Example 1 — Basic Conversion

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

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

💡 Note: Elements 0-1 form first row [1,2], elements 2-3 form second row [3,4], creating a 2×2 matrix

Example 2 — Impossible Case

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

› Output: []

💡 Note: Need 1×5 = 5 elements but only have 3 elements, so return empty array

Example 3 — Single Row

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

› Output: [[1,2]]

💡 Note: All elements fit in one row: [1,2] becomes [[1,2]]

Constraints

1 ≤ original.length ≤ 5 × 10⁴
1 ≤ original[i] ≤ 10⁵
1 ≤ m, n ≤ 4 × 10⁴

Visualization

Tap to expand

Understanding the Visualization

Input Validation

Check if original.length == m × n

Element Mapping

Map each 1D index to 2D position using division and modulo

Result Formation

Create m×n 2D array with elements in correct positions

Key Takeaway

🎯 Key Insight: Use mathematical mapping (i/n, i%n) to convert linear indices to 2D coordinates efficiently

Asked in

f Facebook 15 a Amazon 12 G Google 8

The key insight is to check if the total elements match m×n, then use index mapping: row = i / n, col = i % n. Best approach uses direct calculation. Time: O(m×n), Space: O(m×n)

Common Approaches

Approach	Time	Space	Notes
✓ Direct Conversion with Validation	O(m×n)	O(m×n)	Check if conversion is possible, then fill the 2D array row by row
Single Pass with Index Calculation	O(m×n)	O(m×n)	Calculate 2D positions directly from 1D indices in one pass

Direct Conversion with Validation — Algorithm Steps

Check if original.length equals m × n
If not valid, return empty array
Create m×n 2D array
Fill row by row using original array indices

Visualization

Tap to expand

Step-by-Step Walkthrough

Validation

Check if original.length == m × n

Row Filling

Fill each row with n consecutive elements

Result

Complete 2D array formed

Code -

solution.c — C

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

int** solution(int* original, int originalSize, int m, int n, int* returnSize, int** returnColumnSizes) {
    if (originalSize != m * n) {
        *returnSize = 0;
        *returnColumnSizes = NULL;
        return NULL;
    }
    
    int** result = (int**)malloc(m * sizeof(int*));
    *returnColumnSizes = (int*)malloc(m * sizeof(int));
    *returnSize = m;
    
    for (int i = 0; i < m; i++) {
        result[i] = (int*)malloc(n * sizeof(int));
        (*returnColumnSizes)[i] = n;
        for (int j = 0; j < n; j++) {
            result[i][j] = original[i * n + j];
        }
    }
    
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int original[1000];
    int size = 0;
    char* token = strtok(line, "[,]\n");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != ' ') {
            original[size++] = atoi(token);
        }
        token = strtok(NULL, "[,]\n");
    }
    
    int m, n;
    scanf("%d", &m);
    scanf("%d", &n);
    
    int returnSize;
    int* returnColumnSizes;
    int** result = solution(original, size, m, n, &returnSize, &returnColumnSizes);
    
    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)

We iterate through all m×n elements once to fill the result array

✓ Linear Growth

Space Complexity

O(m×n)

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

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~12 min Avg. Time

890 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 Conversion with Validation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler