# Program to concatenate two given Matrices of same size

• Last Updated : 07 Aug, 2022

Given two matrices A and B of size M x N, the task is to concatenate them into one matrix.
Concatenation of matrix: The process of appending elements of every row of the matrix one after the other is known as the Concatenation of matrix.
Examples:

```Input:
A[][] = {{1, 2},
{3, 4}},
B[][] = {{5, 6},
{7, 8}}
Output:
1 2 5 6
3 4 7 8
Explanation:
Elements of every row of the matrix B
is appended into the row of matrix A.

Input:
A[][] = {{2, 4},
{3, 4}}
B[][] = {{1, 2},
{1, 3}}
Output:
2 4 1 2
3 4 1 3```

Approach: The idea is to declare a matrix of size N x 2*M, then traverse over matrix A and store the elements in the first half of the matrix and then similarly iterate over matrix B and store the elements in another half of the matrix with the help of the below formulae:

```// For filling the
// first half of matrix
matrix[i][j] = A[i][j]

// For filling the
// second half of matrix
matrix[i][j+N] = A[i][j + N]```

Below is the implementation of the above approach:

## C++

 `// C++ implementation to concatenate``// two matrices of size N x M` `#include ` `using` `namespace` `std;` `#define M 2``#define N 2` `// Function to concatenate two``// matrices A[][] and B[][]``void` `mergeMatrix(``int` `A[M][N],``                 ``int` `B[M][N])``{` `    ``// Matrix to store``    ``// the result``    ``int` `C[M][2 * N];` `    ``// Merge the two matrices``    ``for` `(``int` `i = 0; i < M; i++) {``        ``for` `(``int` `j = 0; j < N; j++) {` `            ``// To store elements``            ``// of matrix A``            ``C[i][j] = A[i][j];` `            ``// To store elements``            ``// of matrix B``            ``C[i][j + N] = B[i][j];``        ``}``    ``}` `    ``// Print the result``    ``for` `(``int` `i = 0; i < M; i++) {``        ``for` `(``int` `j = 0; j < 2 * N;``             ``j++)``            ``cout << C[i][j] << ``" "``;``        ``cout << endl;``    ``}``}` `// Driven Code``int` `main()``{``    ``int` `A[M][N] = { { 1, 2 },``                    ``{ 3, 4 } };` `    ``int` `B[M][N] = { { 5, 6 },``                    ``{ 7, 8 } };` `    ``// Find the merge of``    ``// the 2 matrices``    ``mergeMatrix(A, B);` `    ``return` `0;``}`

## Java

 `// Java implementation to concatenate``// two matrices of size N x M``class` `GFG{` `static` `final` `int` `M = ``2``;``static` `final` `int` `N = ``2``;` `// Function to concatenate two``// matrices A[][] and B[][]``static` `void` `mergeMatrix(``int` `A[][],``                        ``int` `B[][])``{` `    ``// Matrix to store``    ``// the result``    ``int` `[][]C = ``new` `int``[M][``2` `* N];` `    ``// Merge the two matrices``    ``for``(``int` `i = ``0``; i < M; i++)``    ``{``       ``for``(``int` `j = ``0``; j < N; j++)``       ``{``          ``// To store elements``          ``// of matrix A``          ``C[i][j] = A[i][j];``          ` `          ``// To store elements``          ``// of matrix B``          ``C[i][j + N] = B[i][j];``           ` `       ``}``    ``}` `    ``// Print the result``    ``for``(``int` `i = ``0``; i < M; i++)``    ``{``       ``for``(``int` `j = ``0``; j < ``2` `* N; j++)``          ``System.out.print(C[i][j] + ``" "``);` `       ``System.out.println();``    ``}``}` `// Driven Code``public` `static` `void` `main(String[] args)``{``    ``int` `A[][] = { { ``1``, ``2` `},``                  ``{ ``3``, ``4` `} };` `    ``int` `B[][] = { { ``5``, ``6` `},``                  ``{ ``7``, ``8` `} };` `    ``// Find the merge of``    ``// the 2 matrices``    ``mergeMatrix(A, B);``}``}` `// This code is contributed by gauravrajput1`

## Python3

 `# Python3 implementation to concatenate``# two matrices of size N x M` `M ``=` `2``N ``=` `2` `# Function to concatenate two``# matrices A[][] and B[][]``def` `mergeMatrix(A, B):` `    ``# Matrix to store``    ``# the result``    ``C ``=` `[[``0` `for` `j ``in` `range``(``2` `*` `N)]``            ``for` `i ``in` `range``(M)]``    ` `    ``# Merge the two matrices``    ``for` `i ``in` `range``(M):``        ``for` `j ``in` `range``(N):``            ` `            ``# To store elements``            ``# of matrix A``            ``C[i][j] ``=` `A[i][j]``            ` `            ``# To store elements``            ``# of matrix B``            ``C[i][j ``+` `N] ``=` `B[i][j]``    ` `    ``# Print the result``    ``for` `i ``in` `range``(M):``        ``for` `j ``in` `range``(``2` `*` `N):    ``            ``print``(C[i][j], end ``=` `' '``)``            ` `        ``print``()` `# Driver code``if` `__name__``=``=``'__main__'``:``    ` `    ``A ``=` `[ [``1``, ``2``], [``3``, ``4``] ]``    ``B ``=` `[ [``5``, ``6``], [``7``, ``8``] ]``    ` `    ``# Find the merge of``    ``# the 2 matrices``    ``mergeMatrix(A, B)` `# This code is contributed by rutvik_56`

## C#

 `// C# implementation to concatenate``// two matrices of size N x M``using` `System;` `class` `GFG{``    ` `const` `int` `M = 2;``const` `int` `N = 2;``    ` `// Function to concatenate two``// matrices A[][] and B[][]``static` `void` `mergeMatrix(``int``[,] A, ``int``[,] B)``{``    ` `    ``// Matrix to store``    ``// the result``    ``int``[,] C = ``new` `int``[M, 2 * N];``    ` `    ``// Merge the two matrices``    ``for``(``int` `i = 0; i < M; i++)``    ``{``       ``for``(``int` `j = 0; j < N; j++)``       ``{``           ` `          ``// To store elements``          ``// of matrix A``          ``C[i, j] = A[i, j];``          ` `          ``// To store elements``          ``// of matrix B``          ``C[i, j + N] = B[i, j];``       ``}``    ``}``    ` `    ``// Print the result``    ``for``(``int` `i = 0; i < M; i++)``    ``{``       ``for``(``int` `j = 0; j < 2 * N; j++)``          ``Console.Write(C[i, j] + ``" "``);``    ` `       ``Console.WriteLine();``    ``}``}` `// Driver code``static` `void` `Main()``{``    ``int``[,] A = { { 1, 2 },``                 ``{ 3, 4 } };` `    ``int``[,] B = { { 5, 6 },``                 ``{ 7, 8 } };``    ` `    ``// Find the merge of``    ``// the 2 matrices``    ``mergeMatrix(A, B);``}``}` `// This code is contributed by divyeshrabadiya07`

## Javascript

 ``

Output:

```1 2 5 6
3 4 7 8```

Time Complexity: O(M * N)

Auxiliary Space: O(M * N), since M * N extra space has been taken.

My Personal Notes arrow_drop_up