Convert 1D Array Into 2D Array

Problem Statement

Suppose you have been provided with a one-dimensional (1D) integer array named original and two integers, m (the number of rows) and n (the number of columns). Your objective is to construct a two-dimensional (2D) array using all the elements from the original array. Each row in the resulting 2D array should sequentially take n elements from the original array based on its indices, starting with indices 0 to n-1 for the first row, then n to 2*n-1 for the second row, and so forth until all elements are used. You need to ensure that the total number of elements required to fill the 2D array (m*n) matches the length of original. If it is not possible to fill the array completely and exactly, you are required to return an empty 2D array.

Examples

Example 1

Input:

original = [1,2,3,4], m = 2, n = 2

Output:

[[1,2],[3,4]]

Explanation:

The constructed 2D array should contain 2 rows and 2 columns.
The first group of n=2 elements in original, [1,2], becomes the first row in the constructed 2D array.
The second group of n=2 elements in original, [3,4], becomes the second row in the constructed 2D array.

Example 2

Input:

original = [1,2,3], m = 1, n = 3

Output:

[[1,2,3]]

Explanation:

The constructed 2D array should contain 1 row and 3 columns.
Put all three elements in original into the first row of the constructed 2D array.

Example 3

Input:

original = [1,2], m = 1, n = 1

Output:

[]

Explanation:

There are 2 elements in original.
It is impossible to fit 2 elements in a 1x1 2D array, so return an empty 2D array.

Constraints

• 1 <= original.length <= 5 * 104
• 1 <= original[i] <= 105
• 1 <= m, n <= 4 * 104

Approach and Intuition

The total number of elements in the input list (original) must be exactly equal to the product of m and n for a valid transformation. If this condition is not met, an immediate return of an empty array is warranted. Here's how you can conceptualize your approach:

1. Check for Valid Input Dimension: Start by verifying if the total count of elements, when grouped into n elements per group, equals exactly m rows. This is a preliminary check to see if a complete and valid 2D array can be constructed.

2. Construct the 2D Array: Provided the preliminary check is successful, process the original array:

   • Create groups of n elements for each of the m rows.
   • Iterate through the original array and slice it into segments of n elements;
   • Append each segment as a row into your 2D array.

3. Return the Result: After processing the complete list, the result should be a 2D array that conforms to the defined row (m) and column (n) structure. If there was a size mismatch, you should have already returned an empty array before this step.

• Example Overview: For example, given original = [1,2,3,4] and m = 2, n = 2, the method ensures 4 elements can exactly fill a 2 x 2 array. It forms the first row with the first two elements [1,2] and the second row with the next two [3,4].

This approach is direct and primarily takes advantage of Python's capabilities to slice lists and handle basic conditional checks efficiently. Compliance with the constraints ensures no overflow or excessive computations.

Solutions

class Solution {
public:
    vector<vector<int>> createMatrix(vector<int>& inputVector, int rows, int cols) {
        // Return an empty matrix if the total number of elements does not match with rows*cols
        if (rows * cols != inputVector.size()) {
            return {};
        }
    
        // Prepare a matrix with proper dimensions
        vector<vector<int>> matrix(rows, vector<int>(cols));
    
        // Populate the matrix using elements from inputVector
        for (int idx = 0; idx < inputVector.size(); idx++) {
            matrix[idx / cols][idx % cols] = inputVector[idx];
        }
    
        return matrix;
    }
};