Related Articles
Program to check if matrix is singular or not
• Difficulty Level : Hard
• Last Updated : 08 Apr, 2019

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++

 `// 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

 `// 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 */`

## Python3

 `# 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#

 `// 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.

My Personal Notes arrow_drop_up
Recommended Articles
Page :