# Program to check if matrix is singular or not

A matrix is said to be singular if the determinant of the matrix is 0 otherwise it is non-singular .

Examples:

```Input :  0 0 0
4 5 6
1 2 3
Output : Yes
Determinant value of the matrix is
0 (Note first row is 0)

Input :  1 0 0
4 5 6
1 2 3
Output : No
Determinant value of the matrix is 3
(which is non-zero).
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

First find the determinant of the matrix and the check the condition if the determinant id 0 or not, if it is 0 then matrix is a singular matrix otherwise it is a non-singular matrix .

 `// C++ program check if a matrix is ` `// singular or not. ` `#include ` `using` `namespace` `std; ` `#define N 4 ` ` `  `// Function to get cofactor of mat[p][q] in temp[][]. ` `// n is current dimension of mat[][] ` `void` `getCofactor(``int` `mat[N][N], ``int` `temp[N][N], ``int` `p,  ` `                                         ``int` `q, ``int` `n) ` `{ ` `    ``int` `i = 0, j = 0; ` ` `  `    ``// Looping for each element of the matrix ` `    ``for` `(``int` `row = 0; row < n; row++) { ` `        ``for` `(``int` `col = 0; col < n; col++) { ` ` `  `            ``// Copying into temporary matrix only  ` `            ``// those element which are not in given  ` `            ``// row and column ` `            ``if` `(row != p && col != q) { ` `                ``temp[i][j++] = mat[row][col]; ` ` `  `                ``// Row is filled, so increase row ` `                ``// index and reset col index ` `                ``if` `(j == n - 1) { ` `                    ``j = 0; ` `                    ``i++; ` `                ``} ` `            ``} ` `        ``} ` `    ``} ` `} ` ` `  `/* Recursive function to check if mat[][] is ` `   ``singular or not. */` `bool` `isSingular(``int` `mat[N][N], ``int` `n) ` `{ ` `    ``int` `D = 0; ``// Initialize result ` ` `  `    ``// Base case : if matrix contains single element ` `    ``if` `(n == 1) ` `        ``return` `mat; ` ` `  `    ``int` `temp[N][N]; ``// To store cofactors ` ` `  `    ``int` `sign = 1; ``// To store sign multiplier ` ` `  `    ``// Iterate for each element of first row ` `    ``for` `(``int` `f = 0; f < n; f++) { ` ` `  `        ``// Getting Cofactor of mat[f] ` `        ``getCofactor(mat, temp, 0, f, n); ` `        ``D += sign * mat[f] * isSingular(temp, n - 1); ` ` `  `        ``// terms are to be added with alternate sign ` `        ``sign = -sign; ` `    ``} ` ` `  `    ``return` `D; ` `} ` ` `  `// Driver program to test above functions ` `int` `main() ` `{ ` `    ``int` `mat[N][N] = { { 4, 10, 1 }, ` `                      ``{ 0, 0, 0 }, ` `                      ``{ 1, 4, -3 } }; ` `    ``if` `(isSingular(mat, N)) ` `        ``cout << ``"Matrix is Singular"` `<< endl; ` `    ``else` `        ``cout << ``"Matrix is non-singular"` `<< endl; ` `    ``return` `0; ` `} `

 `// Java program check if a matrix is  ` `// singular or not.  ` `class` `GFG  ` `{ ` ` `  `    ``static` `final` `int` `N = ``3``; ` ` `  `    ``// Function to get cofactor of mat[p][q] in temp[][].  ` `    ``// n is current dimension of mat[][]  ` `    ``static` `void` `getCofactor(``int` `mat[][], ``int` `temp[][], ``int` `p, ` `                                              ``int` `q, ``int` `n) ` `    ``{ ` `        ``int` `i = ``0``, j = ``0``; ` ` `  `        ``// Looping for each element of the matrix  ` `        ``for` `(``int` `row = ``0``; row < n; row++)  ` `        ``{ ` `            ``for` `(``int` `col = ``0``; col < n; col++)  ` `            ``{ ` ` `  `                ``// Copying into temporary matrix only  ` `                ``// those element which are not in given  ` `                ``// row and column  ` `                ``if` `(row != p && col != q)  ` `                ``{ ` `                    ``temp[i][j++] = mat[row][col]; ` ` `  `                    ``// Row is filled, so increase row  ` `                    ``// index and reset col index  ` `                    ``if` `(j == n - ``1``) ` `                    ``{ ` `                        ``j = ``0``; ` `                        ``i++; ` `                    ``} ` `                ``} ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``/* Recursive function to check if mat[][] is  ` `    ``singular or not. */` `    ``static` `int` `isSingular(``int` `mat[][], ``int` `n)  ` `    ``{ ` `        ``int` `D = ``0``; ``// Initialize result  ` ` `  `        ``// Base case : if matrix contains single element  ` `        ``if` `(n == ``1``) ` `        ``{ ` `            ``return` `mat[``0``][``0``]; ` `        ``} ` ` `  `        ``int` `temp[][] = ``new` `int``[N][N]; ``// To store cofactors  ` ` `  `        ``int` `sign = ``1``; ``// To store sign multiplier  ` ` `  `        ``// Iterate for each element of first row  ` `        ``for` `(``int` `f = ``0``; f < n; f++) ` `        ``{ ` ` `  `            ``// Getting Cofactor of mat[f]  ` `            ``getCofactor(mat, temp, ``0``, f, n); ` `            ``D += sign * mat[``0``][f] * isSingular(temp, n - ``1``); ` ` `  `            ``// terms are to be added with alternate sign  ` `            ``sign = -sign; ` `        ``} ` ` `  `        ``return` `D; ` `    ``} ` ` `  `    ``// Driver code  ` `    ``public` `static` `void` `main(String[] args)  ` `    ``{ ` `        ``int` `mat[][] = {{``4``, ``10``, ``1``}, ` `                        ``{``0``, ``0``, ``0``}, ` `                        ``{``1``, ``4``, -``3``}}; ` `        ``if` `(isSingular(mat, N) == ``1``)  ` `        ``{ ` `            ``System.out.println(``"Matrix is Singular"``); ` `        ``}  ` `        ``else`  `        ``{ ` `            ``System.out.println(``"Matrix is non-singular"``); ` `        ``} ` `    ``} ` `} ` ` `  `/* This code contributed by PrinciRaj1992 */`

 `# python 3 program check if a matrix is ` `# singular or not. ` `global` `N ` `N ``=` `3` ` `  `# Function to get cofactor of mat[p][q] in temp[][]. ` `# n is current dimension of mat[][] ` `def` `getCofactor(mat,temp,p,q,n): ` `    ``i ``=` `0` `    ``j ``=` `0` `     `  `    ``# Looping for each element of the matrix ` `    ``for` `row ``in` `range``(n): ` `        ``for` `col ``in` `range``(n): ` `             `  `            ``# Copying into temporary matrix only  ` `            ``# those element which are not in given  ` `            ``# row and column ` `            ``if` `(row !``=` `p ``and` `col !``=` `q): ` `                ``temp[i][j] ``=` `mat[row][col] ` `                ``j ``+``=` `1` `                 `  `                ``# Row is filled, so increase row ` `                ``# index and reset col index ` `                ``if` `(j ``=``=` `n ``-` `1``): ` `                    ``j ``=` `0` `                    ``i ``+``=` `1` ` `  `# Recursive function to check if mat[][] is ` `# singular or not. */ ` `def` `isSingular(mat,n): ` `    ``D ``=` `0` `# Initialize result ` `     `  `    ``# Base case : if matrix contains single element ` `    ``if` `(n ``=``=` `1``): ` `        ``return` `mat[``0``][``0``] ` `         `  `    ``temp ``=` `[[``0` `for` `i ``in` `range``(N ``+` `1``)] ``for` `i ``in` `range``(N ``+` `1``)]``# To store cofactors ` `     `  `    ``sign ``=` `1` `# To store sign multiplier ` ` `  `    ``# Iterate for each element of first row ` `    ``for` `f ``in` `range``(n): ` `         `  `        ``# Getting Cofactor of mat[f] ` `        ``getCofactor(mat, temp, ``0``, f, n) ` `        ``D ``+``=` `sign ``*` `mat[``0``][f] ``*` `isSingular(temp, n ``-` `1``) ` `         `  `        ``# terms are to be added with alternate sign ` `        ``sign ``=` `-``sign ` `    ``return` `D ` ` `  `# Driver program to test above functions ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``mat ``=` `[[``4``, ``10``, ``1``],[``0``, ``0``, ``0``],[``1``, ``4``, ``-``3``]] ` `    ``if` `(isSingular(mat, N)): ` `        ``print``(``"Matrix is Singular"``) ` `    ``else``: ` `        ``print``(``"Matrix is non-singular"``) ` ` `  `# This code is contributed by ` `# Surendra_Gangwar `

 `// C# program check if a matrix is  ` `// singular or not. ` `using` `System; ` ` `  `class` `GFG  ` `{ ` ` `  `    ``static` `readonly` `int` `N = 3; ` ` `  `    ``// Function to get cofactor of mat[p,q] in temp[,].  ` `    ``// n is current dimension of mat[,]  ` `    ``static` `void` `getCofactor(``int` `[,]mat, ``int` `[,]temp, ``int` `p, ` `                                            ``int` `q, ``int` `n) ` `    ``{ ` `        ``int` `i = 0, j = 0; ` ` `  `        ``// Looping for each element of the matrix  ` `        ``for` `(``int` `row = 0; row < n; row++)  ` `        ``{ ` `            ``for` `(``int` `col = 0; col < n; col++)  ` `            ``{ ` ` `  `                ``// Copying into temporary matrix only  ` `                ``// those element which are not in given  ` `                ``// row and column  ` `                ``if` `(row != p && col != q)  ` `                ``{ ` `                    ``temp[i, j++] = mat[row, col]; ` ` `  `                    ``// Row is filled, so increase row  ` `                    ``// index and reset col index  ` `                    ``if` `(j == n - 1) ` `                    ``{ ` `                        ``j = 0; ` `                        ``i++; ` `                    ``} ` `                ``} ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``/* Recursive function to check if mat[,] is  ` `    ``singular or not. */` `    ``static` `int` `isSingular(``int` `[,]mat, ``int` `n)  ` `    ``{ ` `        ``int` `D = 0; ``// Initialize result  ` ` `  `        ``// Base case : if matrix contains single element  ` `        ``if` `(n == 1) ` `        ``{ ` `            ``return` `mat[0, 0]; ` `        ``} ` ` `  `        ``int` `[,]temp = ``new` `int``[N, N]; ``// To store cofactors  ` ` `  `        ``int` `sign = 1; ``// To store sign multiplier  ` ` `  `        ``// Iterate for each element of first row  ` `        ``for` `(``int` `f = 0; f < n; f++) ` `        ``{ ` ` `  `            ``// Getting Cofactor of mat[0,f]  ` `            ``getCofactor(mat, temp, 0, f, n); ` `            ``D += sign * mat[0, f] * isSingular(temp, n - 1); ` ` `  `            ``// terms are to be added with alternate sign  ` `            ``sign = -sign; ` `        ``} ` ` `  `        ``return` `D; ` `    ``} ` ` `  `    ``// Driver code  ` `    ``public` `static` `void` `Main(String[] args)  ` `    ``{ ` `        ``int` `[,]mat = {{4, 10, 1}, ` `                        ``{0, 0, 0}, ` `                        ``{1, 4, -3}}; ` `        ``if` `(isSingular(mat, N) == 1)  ` `        ``{ ` `            ``Console.WriteLine(``"Matrix is Singular"``); ` `        ``}  ` `        ``else` `        ``{ ` `            ``Console.WriteLine(``"Matrix is non-singular"``); ` `        ``} ` `    ``} ` `} ` ` `  `// This code contributed by Rajput-Ji `

Output:
```Matrix is non-singular
```

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.

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :