Related Articles
Convert a Matrix into another Matrix of given dimensions
• Last Updated : 13 Jan, 2021

Given a matrix, mat[][] of size N * M and two positive integers A and B, the task is to construct a matrix of size A * B from the given matrix elements. If multiple solutions exist, then print any one of them. Otherwise, print -1.

Input: mat[][] = { { 1, 2, 3, 4, 5, 6 } }, A = 2, B = 3
Output: { { 1, 2, 3 }, { 4, 5, 6 } }
Explanation
Since the size of the matrix { { 1, 2, 3 }, { 4, 5, 6 } } is A * B(2 * 3).
Therefore, the required output is { { 1, 2, 3 }, { 4, 5, 6 } }.

Input: mat[][] = { {1, 2}, { 3, 4 }, { 5, 6 } }, A = 1, B = 6
Output: { { 1, 2, 3, 4, 5, 6 } }

Approach: Follow the steps below to solve the problem:

• Initialize a matrix of size A * B say, res[][].
• Traverse the matrix, mat[][] and insert each element of the matrix into the matrix, res[][].
• Finally, print the matrix res[][].

Below is the implementation of the above approach:

## C++

 `// C++ program to implement` `// the above approach` `#include ` `using` `namespace` `std;`   `// Function to construct a matrix of size ` `// A * B from the given matrix elements` `void` `ConstMatrix(``int``* mat, ``int` `N, ``int` `M, ` `                 ``int` `A, ``int` `B)` `{` `    ``if` `(N * M != A * B)` `        ``return``;` `        `  `    ``int` `idx = 0;`   `    ``// Initialize a new matrix` `    ``int` `res[A][B];`   `    ``// Traverse the matrix, mat[][]` `    ``for``(``int` `i = 0; i < N; i++) ` `    ``{` `        ``for``(``int` `j = 0; j < M; j++)` `        ``{` `            ``res[idx / B][idx % B] = *((mat + i * M) + j);`   `            ``// Update idx` `            ``idx++;` `        ``}` `    ``}`   `    ``// Print the resultant matrix` `    ``for``(``int` `i = 0; i < A; i++) ` `    ``{` `        ``for``(``int` `j = 0; j < B; j++)` `            ``cout << res[i][j] << ``" "``;` `            `  `        ``cout << ``"\n"``;` `    ``}` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `mat[][6] = { { 1, 2, 3, 4, 5, 6 } };` `    ``int` `A = 2;` `    ``int` `B = 3;` `    `  `    ``int` `N = ``sizeof``(mat) / ``sizeof``(mat[0]);` `    ``int` `M = ``sizeof``(mat[0]) / ``sizeof``(``int``);` `    `  `    ``ConstMatrix((``int``*)mat, N, M, A, B);` `    `  `    ``return` `0;` `}`   `// This code is contributed by subhammahato348`

## Java

 `// Java program to implement` `// the above approach` `import` `java.util.*;` `class` `GFG` `{`   `// Function to cona matrix of size ` `// A * B from the given matrix elements` `static` `void` `ConstMatrix(``int``[][] mat, ``int` `N, ``int` `M, ` `                 ``int` `A, ``int` `B)` `{` `    ``if` `(N * M != A * B)` `        ``return``;` `        `  `    ``int` `idx = ``0``;`   `    ``// Initialize a new matrix` `    ``int` `[][]res = ``new` `int``[A][B];`   `    ``// Traverse the matrix, mat[][]` `    ``for``(``int` `i = ``0``; i < N; i++) ` `    ``{` `        ``for``(``int` `j = ``0``; j < M; j++)` `        ``{` `            ``res[idx / B][idx % B] = mat[i][j];`   `            ``// Update idx` `            ``idx++;` `        ``}` `    ``}`   `    ``// Print the resultant matrix` `    ``for``(``int` `i = ``0``; i < A; i++) ` `    ``{` `        ``for``(``int` `j = ``0``; j < B; j++)` `            ``System.out.print(res[i][j] + ``" "``);            ` `        ``System.out.print(``"\n"``);` `    ``}` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``int` `mat[][] = { { ``1``, ``2``, ``3``, ``4``, ``5``, ``6` `} };` `    ``int` `A = ``2``;` `    ``int` `B = ``3``;    ` `    ``int` `N = mat.length;` `    ``int` `M = mat[``0``].length;    ` `    ``ConstMatrix(mat, N, M, A, B);    ` `}` `}`   `// This code is contributed by 29AjayKumar `

## Python3

 `# Python3 program to implement` `# the above approach`     `# Function to construct a matrix of size A * B` `# from the given matrix elements` `def` `ConstMatrix(mat, N, M, A, B):` `    ``if` `(N ``*` `M !``=` `A ``*` `B):` `        ``return` `-``1` `    ``idx ``=` `0``;` `    `  `    `  `    ``# Initialize a new matrix` `    ``res ``=` `[[``0` `for` `i ``in` `range``(B)] ``for` `i ``in` `range``(A)]` `    `  `    `  `    ``# Traverse the matrix, mat[][]` `    ``for` `i ``in` `range``(N):` `        ``for` `j ``in` `range``(M):` `            ``res[idx``/``/``B][idx ``%` `B] ``=` `mat[i][j];` `            `  `            `  `            ``# Update idx` `            ``idx ``+``=` `1` `    `  `    `  `    ``# Print the resultant matrix` `    ``for` `i ``in` `range``(A):` `        ``for` `j ``in` `range``(B):` `            ``print``(res[i][j], end ``=` `" "``)` `        ``print``()`       `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    `  `    ``mat ``=` `[ [ ``1``, ``2``, ``3``, ``4``, ``5``, ``6` `] ]` `    ``A ``=` `2` `    ``B ``=` `3` `    ``N ``=` `len``(mat)` `    ``M ``=` `len``(mat[``0``])` `    ``ConstMatrix(mat, N, M, A, B)`

## C#

 `// C# program to implement` `// the above approach` `using` `System;` `class` `GFG` `{`   `// Function to cona matrix of size ` `// A * B from the given matrix elements` `static` `void` `ConstMatrix(``int``[,] mat, ``int` `N, ``int` `M, ` `                 ``int` `A, ``int` `B)` `{` `    ``if` `(N * M != A * B)` `        ``return``;        ` `    ``int` `idx = 0;`   `    ``// Initialize a new matrix` `    ``int` `[,]res = ``new` `int``[A,B];`   `    ``// Traverse the matrix, [,]mat` `    ``for``(``int` `i = 0; i < N; i++) ` `    ``{` `        ``for``(``int` `j = 0; j < M; j++)` `        ``{` `            ``res[idx / B, idx % B] = mat[i, j];`   `            ``// Update idx` `            ``idx++;` `        ``}` `    ``}`   `    ``// Print the resultant matrix` `    ``for``(``int` `i = 0; i < A; i++) ` `    ``{` `        ``for``(``int` `j = 0; j < B; j++)` `            ``Console.Write(res[i, j] + ``" "``);            ` `        ``Console.Write(``"\n"``);` `    ``}` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `    ``int` `[,]mat = {{ 1, 2, 3, 4, 5, 6 }};` `    ``int` `A = 2;` `    ``int` `B = 3;    ` `    ``int` `N = mat.GetLength(0);` `    ``int` `M = mat.GetLength(1);    ` `    ``ConstMatrix(mat, N, M, A, B);    ` `}` `}`   `// This code is contributed by 29AjayKumar`

Output:

```1 2 3
4 5 6```

Time Complexity: O(N * M)
Auxiliary Space: O(N * M)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up
Recommended Articles
Page :