Convert 1D Array Into 2D Array

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;
    }
};

This article describes the solution to convert a one-dimensional vector into a two-dimensional matrix using C++. The provided C++ function named createMatrix takes three parameters:

• inputVector - a reference to a 1D vector of integers.
• rows - the desired number of rows in the resulting 2D matrix.
• cols - the desired number of columns in the resulting 2D matrix.

To achieve the transformation, follow these steps:

1. Confirm whether the product of rows and cols equals the size of the inputVector. If not, return an empty matrix as the dimensions do not allow a perfect reshaping without losing or truncating data.
2. Initialize a 2D matrix matrix with dimensions specified by rows and cols.
3. Populate this matrix by iterating over inputVector. For each element in inputVector, calculate the relevant row index as integer division of idx (current index) by cols and column index as the remainder of dividing idx by cols. Assign the value from the 1D inputVector to the correct position in the 2D matrix using these indices.
4. After looping through all elements, return the populated matrix.

The function handles edge cases like mismatched dimensions by returning an empty matrix, ensuring the integrity of data conversion is preserved regardless of input scenarios. Therefore, you have a robust, reusable function for matrix transformations in C++.

class Solution {

    public int[][] buildMatrix(int[] sourceArray, int rows, int cols) {
        if (rows * cols != sourceArray.length) {
            return new int[0][0];
        }

        int[][] matrix = new int[rows][cols];

        for (int index = 0; index < sourceArray.length; index++) {
            matrix[index / cols][index % cols] = sourceArray[index];
        }

        return matrix;
    }
}

This Java solution converts a 1D array into a 2D array based on specified row and column parameters. Ensure the product of the rows and columns matches the length of the 1D array; otherwise, the method returns an empty 2D array.

• Start by checking if the product of rows and cols equals the length of sourceArray. If not, return an empty matrix to indicate invalid dimensions.
• Initialize a 2D array, matrix, of size [rows][cols].
• Iterate over the sourceArray, converting 1D index positions to 2D positions within matrix. Use integer division and modulus operations to determine the correct row and column for each element.
• Finally, return the populated matrix.

This method efficiently maps the elements from a 1D array to a 2D matrix using direct index manipulation, ensuring optimal performance with minimal overhead.

class Solution:
    def createMatrix(self, flat_list: list[int], rows: int, cols: int) -> list[list[int]]:
        if rows * cols != len(flat_list):
            return []

        matrix = [[0] * cols for _ in range(rows)]

        for idx in range(len(flat_list)):
            r, c = divmod(idx, cols)
            matrix[r][c] = flat_list[idx]

        return matrix

The provided Python code resolves the task of converting a one-dimensional list into a two-dimensional array or matrix, given specific dimensions for rows and columns.

• The primary function createMatrix takes three parameters:

  • flat_list as the list of integers,
  • rows as the intended number of rows,
  • cols as the intended number of columns.

• Initially, it checks if the product of the rows and columns matches the length of flat_list. If it does not, an empty list is returned signaling an error or incompatibility in inputs.

• The function then initializes a matrix of zeros with dimensions defined by the number of rows and columns.

• A loop then iterates through each element in flat_list where:

  1. The current index is converted into row and column indices using the divmod function.
  2. The value from the flat_list is placed into the matrix at the respective [row, column] location.

• Finally, the filled matrix is returned, providing a two-dimensional representation of the input list. This process requires both functional and loop-based operations tailored to the nature and size of flat_list as well as the desired matrix dimensions.