Open in App
Not now

# Program for subtraction of matrices

• Difficulty Level : Basic
• Last Updated : 16 Feb, 2023

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

Implementation:

## 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` `subtract(``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;  ` `    ``subtract(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` `subtract(``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; ` `    ``subtract(A, B, C); ` ` `  `    ``printf``(``"Result matrix is \n"``); ` `    ``for` `(i = 0; i < N; i++) ` `    ``{ ` `        ``for` `(j = 0; j < N; j++) ` `           ``printf``(``"%d "``, C[i][j]); ` `        ``printf``(``"\n"``); ` `    ``} ` ` `  `    ``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` `subtract(``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; ` `        ``subtract(A, B, C); ` `     `  `        ``System.out.print(``"Result matrix is \n"``); ` `        ``for` `(i = ``0``; i < N; i++) ` `        ``{ ` `            ``for` `(j = ``0``; j < N; j++) ` `            ``System.out.print(C[i][j] + ``" "``); ` `            ``System.out.print(``"\n"``); ` `        ``} ` `    ``} ` `} ` ` `  `// 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` `subtract(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 ` `     `  `subtract(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` `subtract(``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; ` `    ``subtract(A, B, C); ` ` `  `    ``Console.Write(``"Result matrix is \n"``); ` `    ``for` `(i = 0; i < N; i++) ` `    ``{ ` `        ``for` `(j = 0; j < N; j++) ` `        ``{ ` `            ``Console.Write(C[i, j] + ``" "``); ` `        ``} ` `        ``Console.Write(``"\n"``); ` `    ``} ` `} ` `} ` ` `  `// This code is contributed by Shrikant13 `

## PHP

 ` `

## Javascript

 ``

Output

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

Note – The number at 0th row and 0th column of first matrix gets subtracted with number at 0th row and 0th column of second matrix. And its subtraction result gets initialized as the value of 0th row and 0th column of resultant matrix. Same subtraction process applied for all the elements

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?

Time complexity: O(n2).
Auxiliary space:O(n2). since n2 extra space has been taken.

My Personal Notes arrow_drop_up
Related Articles