# Check whether a given matrix is orthogonal or not

We are given a matrix, we need to check whether it is an orthogonal matrix or not. An orthogonal matrix is a square matrix and satisfies the following condition:

`  A*At = I`

Examples :

```Input:  1 0 0
0 1 0
0 0 1
Output: Yes
Given Matrix is an orthogonal matrix. When
we multiply it with its transpose, we get
identity matrix.

Input:  1 2 3
4 5 6
7 8 9
Output: No
Given Matrix Is Not An Orthogonal Matrix
```

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

Simple Solution : The idea is simple, we first find transpose of matrix. Then we multiply the transpose with given matrix. Finally we check if the matrix obtained is identity or not.

 `// C++ code to check whether ` `// a matrix is orthogonal or not ` `#include ` `using` `namespace` `std; ` ` `  `#define MAX 100 ` ` `  `bool` `isOrthogonal(``int` `a[][MAX],  ` `                  ``int` `m, ``int` `n)  ` `{ ` `if` `(m != n) ` `    ``return` `false``; ` ` `  `// Find transpose ` `int` `trans[n][n]; ` `for` `(``int` `i = 0; i < n; i++) ` `    ``for` `(``int` `j = 0; j < n; j++) ` `    ``trans[i][j] = a[j][i]; ` ` `  `// Find product of a[][]  ` `// and its transpose ` `int` `prod[n][n]; ` `for` `(``int` `i = 0; i < n; i++)  ` `{ ` `    ``for` `(``int` `j = 0; j < n; j++)  ` `    ``{ ` ` `  `    ``int` `sum = 0; ` `    ``for` `(``int` `k = 0; k < n; k++)  ` `    ``{ ` ` `  `        ``// Since we are multiplying with ` `        ``// transpose of itself. We use ` `        ``sum = sum + (a[i][k] * a[j][k]); ` `    ``} ` ` `  `    ``prod[i][j] = sum; ` `    ``} ` `} ` ` `  `// Check if product is identity matrix ` `for` `(``int` `i = 0; i < n; i++)  ` `{ ` `    ``for` `(``int` `j = 0; j < n; j++)  ` `    ``{ ` `    ``if` `(i != j && prod[i][j] != 0) ` `        ``return` `false``; ` `    ``if` `(i == j && prod[i][j] != 1) ` `        ``return` `false``; ` `    ``} ` `} ` ` `  `return` `true``; ` `} ` ` `  `// Driver Code ` `int` `main()  ` `{ ` ` `  `int` `a[][MAX] = {{1, 0, 0}, ` `                ``{0, 1, 0}, ` `                ``{0, 0, 1}}; ` `if` `(isOrthogonal(a, 3, 3)) ` `    ``cout << ``"Yes"``; ` `else` `    ``cout << ``"No"``; ` `return` `0; ` `} `

 `// Java code to check whether ` `// a matrix is orthogonal or not ` `import` `java .io.*; ` `class` `GFG { ` `     `  `    ``//static int MAX =100; ` `    ``static` `boolean` `isOrthogonal(``int` `[][]a,  ` `                                ``int` `m,  ` `                                ``int` `n)  ` `    ``{ ` `        ``if` `(m != n) ` `            ``return` `false``; ` `         `  `        ``// Find transpose ` `        ``int` `[][]trans = ``new` `int``[n][n]; ` `        ``for` `(``int` `i = ``0``; i < n; i++) ` `            ``for` `(``int` `j = ``0``; j < n; j++) ` `                ``trans[i][j] = a[j][i]; ` `         `  `        ``// Find product of a[][]  ` `        ``// and its transpose ` `        ``int` `[][]prod = ``new` `int``[n][n]; ` `        ``for` `(``int` `i = ``0``; i < n; i++)  ` `        ``{ ` `            ``for` `(``int` `j = ``0``; j < n; j++)  ` `            ``{ ` `         `  `                ``int` `sum = ``0``; ` `                ``for` `(``int` `k = ``0``; k < n; k++)  ` `                ``{ ` `                    ``// Since we are multiplying  ` `                    ``// transpose of itself. We use ` `                    ``sum = sum + (a[i][k] * a[j][k]); ` `                ``} ` `             `  `                ``prod[i][j] = sum; ` `            ``} ` `        ``} ` `         `  `        ``// Check if product is ` `        ``// identity matrix ` `        ``for` `(``int` `i = ``0``; i < n; i++)  ` `        ``{ ` `            ``for` `(``int` `j = ``0``; j < n; j++)  ` `            ``{ ` `                ``if` `(i != j && prod[i][j] != ``0``) ` `                    ``return` `false``; ` `                ``if` `(i == j && prod[i][j] != ``1``) ` `                    ``return` `false``; ` `            ``} ` `        ``} ` `         `  `        ``return` `true``; ` `    ``} ` `     `  `    ``// Driver code ` `    ``static` `public` `void` `main (String[] args) ` `    ``{ ` `        ``int` `[][]a = {{``1``, ``0``, ``0``}, ` `                    ``{``0``, ``1``, ``0``}, ` `                    ``{``0``, ``0``, ``1``}}; ` `        ``if` `(isOrthogonal(a, ``3``, ``3``)) ` `            ``System.out.println(``"Yes"``); ` `        ``else` `            ``System.out.println(``"No"``); ` `    ``} ` `} ` ` `  `// This code is contributed by anuj_67. `

 `# Python code to check  ` `# whether a matrix is ` `# orthogonal or not ` ` `  `def` `isOrthogonal(a, m, n) : ` `    ``if` `(m !``=` `n) : ` `        ``return` `False` `     `  `    ``trans ``=` `[[``0` `for` `x ``in` `range``(n)]  ` `                ``for` `y ``in` `range``(n)]  ` `                 `  `    ``# Find transpose ` `    ``for` `i ``in` `range``(``0``, n) : ` `        ``for` `j ``in` `range``(``0``, n) : ` `            ``trans[i][j] ``=` `a[j][i] ` `             `  `    ``prod ``=` `[[``0` `for` `x ``in` `range``(n)] ` `               ``for` `y ``in` `range``(n)]  ` `                `  `    ``# Find product of a[][]  ` `    ``# and its transpose ` `    ``for` `i ``in` `range``(``0``, n) : ` `        ``for` `j ``in` `range``(``0``, n) : ` `     `  `            ``sum` `=` `0` `            ``for` `k ``in` `range``(``0``, n) : ` `         `  `                ``# Since we are multiplying  ` `                ``# with transpose of itself. ` `                ``# We use ` `                ``sum` `=` `sum` `+` `(a[i][k] ``*`  `                             ``a[j][k]) ` `     `  `            ``prod[i][j] ``=` `sum` ` `  `    ``# Check if product is  ` `    ``# identity matrix ` `    ``for` `i ``in` `range``(``0``, n) : ` `        ``for` `j ``in` `range``(``0``, n) : ` ` `  `            ``if` `(i !``=` `j ``and` `prod[i][j] !``=` `0``) : ` `                ``return` `False` `            ``if` `(i ``=``=` `j ``and` `prod[i][j] !``=` `1``) : ` `                ``return` `False` ` `  `    ``return` `True` ` `  `# Driver Code ` `a ``=` `[[``1``, ``0``, ``0``], ` `    ``[``0``, ``1``, ``0``], ` `    ``[``0``, ``0``, ``1``]] ` `         `  `if` `(isOrthogonal(a, ``3``, ``3``)) : ` `    ``print` `(``"Yes"``) ` `else` `: ` `    ``print` `(``"No"``) ` ` `  `# This code is contributed by  ` `# Manish Shaw(manishshaw1) `

 `// C# code to check whether ` `// a matrix is orthogonal or not ` `using` `System; ` ` `  `class` `GFG ` `{ ` `     `  `    ``//static int MAX =100; ` `    ``static` `bool` `isOrthogonal(``int` `[,]a,  ` `                             ``int` `m,  ` `                             ``int` `n)  ` `    ``{ ` `        ``if` `(m != n) ` `            ``return` `false``; ` `         `  `        ``// Find transpose ` `        ``int` `[,]trans = ``new` `int``[n, n]; ` `        ``for` `(``int` `i = 0; i < n; i++) ` `            ``for` `(``int` `j = 0; j < n; j++) ` `                ``trans[i, j] = a[j, i]; ` `         `  `        ``// Find product of a[][]  ` `        ``// and its transpose ` `        ``int` `[,]prod = ``new` `int``[n, n]; ` `        ``for` `(``int` `i = 0; i < n; i++)  ` `        ``{ ` `            ``for` `(``int` `j = 0; j < n; j++)  ` `            ``{ ` `         `  `                ``int` `sum = 0; ` `                ``for` `(``int` `k = 0; k < n; k++)  ` `                ``{ ` `                    ``// Since we are multiplying  ` `                    ``// transpose of itself. We use ` `                    ``sum = sum + (a[i, k] * a[j, k]); ` `                ``} ` `             `  `                ``prod[i, j] = sum; ` `            ``} ` `        ``} ` `         `  `        ``// Check if product is ` `        ``// identity matrix ` `        ``for` `(``int` `i = 0; i < n; i++)  ` `        ``{ ` `            ``for` `(``int` `j = 0; j < n; j++)  ` `            ``{ ` `                ``if` `(i != j && prod[i, j] != 0) ` `                    ``return` `false``; ` `                ``if` `(i == j && prod[i, j] != 1) ` `                    ``return` `false``; ` `            ``} ` `        ``} ` `         `  `        ``return` `true``; ` `    ``} ` `     `  `    ``// Driver code ` `    ``static` `public` `void` `Main () ` `    ``{ ` `        ``int` `[,]a = {{1, 0, 0}, ` `                    ``{0, 1, 0}, ` `                    ``{0, 0, 1}}; ` `        ``if` `(isOrthogonal(a, 3, 3)) ` `            ``Console.WriteLine(``"Yes"``); ` `        ``else` `            ``Console.WriteLine(``"No"``); ` `    ``} ` `} ` ` `  `// This code is contributed by vt_m `

 ` `

Output :

```Yes
```

An efficient solution is to combine three traversals into one. Instead of explicitly finding transpose, we use a[j][k] instead of a[k][j]. Also, instead of explicitly computing product, we check identity while computing product.

 `// C++ code to check whether ` `// a matrix is orthogonal or not ` `#include ` `using` `namespace` `std; ` ` `  `#define MAX 100 ` ` `  `bool` `isOrthogonal(``int` `a[][MAX],  ` `                  ``int` `m, ``int` `n)  ` `{ ` `if` `(m != n) ` `    ``return` `false``; ` ` `  `// Multiply A*A^t ` `for` `(``int` `i = 0; i < n; i++)  ` `{ ` `    ``for` `(``int` `j = 0; j < n; j++)  ` `    ``{ ` ` `  `    ``int` `sum = 0; ` `    ``for` `(``int` `k = 0; k < n; k++) ` `    ``{ ` ` `  `        ``// Since we are multiplying with ` `        ``// transpose of itself. We use ` `        ``// a[j][k] instead of a[k][j] ` `        ``sum = sum + (a[i][k] * a[j][k]); ` `    ``} ` ` `  `    ``if` `(i == j && sum != 1) ` `        ``return` `false``; ` `    ``if` `(i != j && sum != 0) ` `        ``return` `false``; ` `    ``} ` `} ` ` `  `return` `true``; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` ` `  `int` `a[][MAX] = {{1, 0, 0}, ` `                ``{0, 1, 0}, ` `                ``{0, 0, 1}}; ` `if` `(isOrthogonal(a, 3, 3)) ` `    ``cout << ``"Yes"``; ` `else` `    ``cout << ``"No"``; ` `return` `0; ` `} `

 `// C# code to check whether ` `// a matrix is orthogonal or not ` `using System; ` ` `  `class` `GFG ` `{ ` `    ``//static int MAX =100; ` ` `  `    ``static` `bool isOrthogonal(``int``[,]a,  ` `                             ``int` `m,  ` `                             ``int` `n)  ` `    ``{ ` `        ``if` `(m != n) ` `            ``return` `false``; ` `         `  `        ``// Multiply A*A^t ` `        ``for` `(``int` `i = ``0``; i < n; i++)  ` `        ``{ ` `            ``for` `(``int` `j = ``0``; j < n; j++) ` `            ``{ ` `         `  `            ``int` `sum = ``0``; ` `            ``for` `(``int` `k = ``0``; k < n; k++)  ` `            ``{ ` `         `  `                ``// Since we are multiplying ` `                ``// with transpose of itself.  ` `                ``// We use a[j][k] instead  ` `                ``// of a[k][j] ` `                ``sum = sum + (a[i, k] * a[j, k]); ` `            ``} ` `         `  `            ``if` `(i == j && sum != ``1``) ` `                ``return` `false``; ` `            ``if` `(i != j && sum != ``0``) ` `                ``return` `false``; ` `            ``} ` `        ``} ` `         `  `        ``return` `true``; ` `    ``} ` `     `  `    ``// Driver code  ` `    ``public` `static` `void` `Main () ` `    ``{ ` `        ``int` `[,]a = {{``1``, ``0``, ``0``}, ` `                    ``{``0``, ``1``, ``0``}, ` `                    ``{``0``, ``0``, ``1``}}; ` `        ``if` `(isOrthogonal(a, ``3``, ``3``)) ` `            ``Console.WriteLine(``"Yes"``); ` `        ``else` `            ``Console.WriteLine(``"No"``); ` `         `  `    ``} ` `} ` ` `  `// This code is contributed by vt_m `

 `# Python code to check  ` `# whether a matrix is  ` `# orthogonal or not ` ` `  `def` `isOrthogonal(a, m, n) : ` `    ``if` `(m !``=` `n) : ` `        ``return` `False` `     `  `    ``# Multiply A*A^t ` `    ``for` `i ``in` `range``(``0``, n) : ` `        ``for` `j ``in` `range``(``0``, n) :  ` `            ``sum` `=` `0` `            ``for` `k ``in` `range``(``0``, n) : ` `         `  `                ``# Since we are multiplying  ` `                ``# with transpose of itself. ` `                ``# We use a[j][k] instead ` `                ``# of a[k][j] ` `                ``sum` `=` `sum` `+` `(a[i][k] ``*` `                             ``a[j][k]) ` `         `  `        ``if` `(i ``=``=` `j ``and` `sum` `!``=` `1``) : ` `            ``return` `False` `        ``if` `(i !``=` `j ``and` `sum` `!``=` `0``) : ` `            ``return` `False` ` `  `    ``return` `True` ` `  `# Driver Code ` `a ``=` `[[``1``, ``0``, ``0``], ` `     ``[``0``, ``1``, ``0``], ` `     ``[``0``, ``0``, ``1``]] ` `if` `(isOrthogonal(a, ``3``, ``3``)) : ` `    ``print` `(``"Yes"``) ` `else` `: ` `    ``print` `(``"No"``) ` `     `  `# This code is contributed by  ` `# Manish Shaw(manishshaw1) `

 `// C# code to check whether ` `// a matrix is orthogonal or not ` `using` `System; ` ` `  `public` `class` `GFG ` `{ ` `    ``//static int MAX =100; ` ` `  `    ``static` `bool` `isOrthogonal(``int``[,]a, ``int` `m, ``int` `n)  ` `    ``{ ` `        ``if` `(m != n) ` `            ``return` `false``; ` `         `  `        ``// Multiply A*A^t ` `        ``for` `(``int` `i = 0; i < n; i++) { ` `            ``for` `(``int` `j = 0; j < n; j++) { ` `         `  `            ``int` `sum = 0; ` `            ``for` `(``int` `k = 0; k < n; k++) { ` `         `  `                ``// Since we are multiplying with ` `                ``// transpose of itself. We use ` `                ``// a[j][k] instead of a[k][j] ` `                ``sum = sum + (a[i,k] * a[j,k]); ` `            ``} ` `         `  `            ``if` `(i == j && sum != 1) ` `                ``return` `false``; ` `            ``if` `(i != j && sum != 0) ` `                ``return` `false``; ` `            ``} ` `        ``} ` `         `  `        ``return` `true``; ` `    ``} ` `     `  `    ``// Driver code     ` `    ``public` `static` `void` `Main () ` `    ``{ ` `                 `  `        ``int` `[,]a = {{1, 0, 0}, ` `                    ``{0, 1, 0}, ` `                    ``{0, 0, 1}}; ` `        ``if` `(isOrthogonal(a, 3, 3)) ` `            ``Console.WriteLine(``"Yes"``); ` `        ``else` `            ``Console.WriteLine(``"No"``); ` `         `  `    ``} ` `} ` ` `  `// This code is contributed by vt_m `

 ` `

Output :
```Yes
```

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.

Improved By : KRV, vt_m, jit_t, manishshaw1

Article Tags :
Practice Tags :