# Program for subtraction of matrices

The below program subtracts of two square matrices of size 4*4, we can change N for different dimension.

## C++

 `// C++ program for subtraction of matrices ` `#include ` `using` `namespace` `std; ` `#define N 4  ` ` `  `// This function subtracts B[][] from A[][], and stores  ` `// the result in C[][]  ` `void` `multiply(``int` `A[][N], ``int` `B[][N], ``int` `C[][N])  ` `{  ` `    ``int` `i, j;  ` `    ``for` `(i = 0; i < N; i++)  ` `        ``for` `(j = 0; j < N; j++)  ` `            ``C[i][j] = A[i][j] - B[i][j];  ` `}  ` ` `  `// Driver code ` `int` `main()  ` `{  ` `    ``int` `A[N][N] = { {1, 1, 1, 1},  ` `                    ``{2, 2, 2, 2},  ` `                    ``{3, 3, 3, 3},  ` `                    ``{4, 4, 4, 4}};  ` ` `  `    ``int` `B[N][N] = { {1, 1, 1, 1},  ` `                    ``{2, 2, 2, 2},  ` `                    ``{3, 3, 3, 3},  ` `                    ``{4, 4, 4, 4}};  ` ` `  `    ``int` `C[N][N]; ``// To store result  ` `    ``int` `i, j;  ` `    ``multiply(A, B, C);  ` ` `  `    ``cout << ``"Result matrix is "` `<< endl;  ` `    ``for` `(i = 0; i < N; i++)  ` `    ``{  ` `        ``for` `(j = 0; j < N; j++)  ` `        ``cout << C[i][j] << ``" "``;  ` `        ``cout << endl;  ` `    ``}  ` ` `  `    ``return` `0;  ` `}  ` ` `  `// This code is contributed by rathbhupendra `

## C

 `#include ` `#define N 4 ` ` `  `// This function subtracts B[][] from A[][], and stores ` `// the result in C[][] ` `void` `multiply(``int` `A[][N], ``int` `B[][N], ``int` `C[][N]) ` `{ ` `    ``int` `i, j; ` `    ``for` `(i = 0; i < N; i++) ` `        ``for` `(j = 0; j < N; j++) ` `            ``C[i][j] = A[i][j] - B[i][j]; ` `} ` ` `  `int` `main() ` `{ ` `    ``int` `A[N][N] = { {1, 1, 1, 1}, ` `                    ``{2, 2, 2, 2}, ` `                    ``{3, 3, 3, 3}, ` `                    ``{4, 4, 4, 4}}; ` ` `  `    ``int` `B[N][N] = { {1, 1, 1, 1}, ` `                    ``{2, 2, 2, 2}, ` `                    ``{3, 3, 3, 3}, ` `                    ``{4, 4, 4, 4}}; ` ` `  `    ``int` `C[N][N]; ``// To store result ` `    ``int` `i, j; ` `    ``multiply(A, B, C); ` ` `  `    ``printf``(````"Result matrix is "````); ` `    ``for` `(i = 0; i < N; i++) ` `    ``{ ` `        ``for` `(j = 0; j < N; j++) ` `           ``printf``(``"%d "``, C[i][j]); ` `        ``printf``(````" "````); ` `    ``} ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program for subtraction of matrices ` ` `  `class` `GFG ` `{ ` `     ``static` `final` `int` `N=``4``; ` ` `  `    ``// This function subtracts B[][]  ` `    ``// from A[][], and stores ` `    ``// the result in C[][] ` `    ``static` `void` `multiply(``int` `A[][], ``int` `B[][], ``int` `C[][]) ` `    ``{ ` `        ``int` `i, j; ` `        ``for` `(i = ``0``; i < N; i++) ` `            ``for` `(j = ``0``; j < N; j++) ` `                ``C[i][j] = A[i][j] - B[i][j]; ` `    ``} ` `     `  `    ``// Driver code ` `    ``public` `static` `void` `main (String[] args) ` `    ``{ ` `        ``int` `A[][] = { {``1``, ``1``, ``1``, ``1``}, ` `                        ``{``2``, ``2``, ``2``, ``2``}, ` `                        ``{``3``, ``3``, ``3``, ``3``}, ` `                        ``{``4``, ``4``, ``4``, ``4``}}; ` `     `  `        ``int` `B[][] = { {``1``, ``1``, ``1``, ``1``}, ` `                        ``{``2``, ``2``, ``2``, ``2``}, ` `                        ``{``3``, ``3``, ``3``, ``3``}, ` `                        ``{``4``, ``4``, ``4``, ``4``}}; ` `                         `  `        ``// To store result ` `        ``int` `C[][]=``new` `int``[N][N];  ` ` `  `        ``int` `i, j; ` `        ``multiply(A, B, C); ` `     `  `        ``System.out.print(````"Result matrix is "````); ` `        ``for` `(i = ``0``; i < N; i++) ` `        ``{ ` `            ``for` `(j = ``0``; j < N; j++) ` `            ``System.out.print(C[i][j] + ``" "``); ` `            ``System.out.print(````" "````); ` `        ``} ` `    ``} ` `} ` ` `  `// This code is contributed by Anant Agarwal. `

## Python3

 `# Python 3 program for subtraction  ` `# of matrices ` ` `  `N ``=` `4` ` `  `# This function returns 1 ` `# if A[][] and B[][] are identical ` `# otherwise returns 0 ` `def` `multiply(A, B, C): ` `     `  `    ``for` `i ``in` `range``(N): ` `        ``for` `j ``in` `range``(N): ` `            ``C[i][j] ``=` `A[i][j] ``-` `B[i][j]  ` ` `  `# Driver Code ` `A ``=` `[ [``1``, ``1``, ``1``, ``1``], ` `      ``[``2``, ``2``, ``2``, ``2``], ` `      ``[``3``, ``3``, ``3``, ``3``], ` `      ``[``4``, ``4``, ``4``, ``4``]] ` ` `  `B ``=` `[ [``1``, ``1``, ``1``, ``1``], ` `      ``[``2``, ``2``, ``2``, ``2``], ` `      ``[``3``, ``3``, ``3``, ``3``], ` `      ``[``4``, ``4``, ``4``, ``4``]] ` `                     `  `C ``=` `A[:][:] ``# To store result ` `     `  `multiply(A, B, C) ` ` `  `print``(``"Result matrix is"``) ` `for` `i ``in` `range``(N): ` `    ``for` `j ``in` `range``(N): ` `        ``print``(C[i][j], ``" "``, end ``=` `'') ` `    ``print``() ` `     `  `# This code is contributed ` `# by Anant Agarwal. `

## C#

 `// C# program for subtraction of matrices  ` `using` `System; ` ` `  `class` `GFG ` `{ ` `static` `int` `N = 4; ` ` `  `// This function subtracts B[][]  ` `// from A[][], and stores  ` `// the result in C[][]  ` `public` `static` `void` `multiply(``int``[][] A,  ` `                            ``int``[][] B,  ` `                            ``int``[, ] C) ` `{ ` `    ``int` `i, j; ` `    ``for` `(i = 0; i < N; i++) ` `    ``{ ` `        ``for` `(j = 0; j < N; j++) ` `        ``{ ` `            ``C[i, j] = A[i][j] - B[i][j]; ` `        ``} ` `    ``} ` `} ` ` `  ` `  `// Driver code  ` `public` `static` `void` `Main(``string``[] args) ` `{ ` `    ``int``[][] A = ``new` `int``[][] ` `    ``{ ` `        ``new` `int``[] {1, 1, 1, 1}, ` `        ``new` `int``[] {2, 2, 2, 2}, ` `        ``new` `int``[] {3, 3, 3, 3}, ` `        ``new` `int``[] {4, 4, 4, 4} ` `    ``}; ` ` `  `    ``int``[][] B = ``new` `int``[][] ` `    ``{ ` `        ``new` `int``[] {1, 1, 1, 1}, ` `        ``new` `int``[] {2, 2, 2, 2}, ` `        ``new` `int``[] {3, 3, 3, 3}, ` `        ``new` `int``[] {4, 4, 4, 4} ` `    ``}; ` ` `  `    ``// To store result  ` ` `  `    ``int``[, ] C = ``new` `int``[N, N]; ` ` `  `    ``int` `i, j; ` `    ``multiply(A, B, C); ` ` `  `    ``Console.Write(````"Result matrix is "````); ` `    ``for` `(i = 0; i < N; i++) ` `    ``{ ` `        ``for` `(j = 0; j < N; j++) ` `        ``{ ` `            ``Console.Write(C[i, j] + ``" "``); ` `        ``} ` `        ``Console.Write(````" "````); ` `    ``} ` `} ` `} ` ` `  `// This code is contributed by Shrikant13 `

/div>

## PHP

 ` `

Output:

```Result matrix is
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0```

The program can be extended for rectangular matrices. The following post can be useful for extending this program.

How to pass a 2D array as a parameter in C?

The time complexity of the above program is O(n2).

## tags:

Matrix School Programming Matrix