# Check horizontal and vertical symmetry in binary matrix

Given a 2D binary matrix of N rows and M columns. The task is to check whether the matrix is horizontal symmetric, vertical symmetric or both. The matrix is said to be horizontal symmetric if the first row is same as the last row, the second row is same as the second last row and so on. And the matrix is said to be vertical symmetric if the first column is same as the last column, the second column is same as the second last column and so on. Print “VERTICAL” if the matrix is vertical symmetric, “HORIZONTAL” if the matrix is vertical symmetric, “BOTH” if the matrix is vertical and horizontal symmetric and “NO” if not symmetric.

Examples :

```Input : N = 3 M = 3
0 1 0
0 0 0
0 1 0
Output : Both
First and third row are same and also second row
is in middle. So Horizontal Symmetric.
Similarly, First and third column are same and
also second column is in middle, so Vertical
Symmetric.

Input :
0 0 1
1 1 0
0 0 1.
Output : Horizontal
```

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

The idea is to use to pointers indicating two rows (or columns) and compare each cell of both the pointed rows (or columns).
For Horizontal Symmetry, initialize one pointer i = 0 and another pointer j = N – 1.
Now, compare each element of i-th row and j-th row. Increase i by 1 and decrease j by 1 in each loop cycle. If at least one not identical element is found, mark matrix as not horizontal symmetric.

Similarly, for Vertical Symmetry, initialize one pointer i = 0 and another pointer j = M – 1.
Now, compare each element of i-th column and j-th column. Increase i by 1 and decrease j by 1 in each loop cycle. If at least one not identical element is found, mark matrix as not vertical symmetric.

Below is the implementation of above idea :

## C++

 `// C++ program to find if a matrix is symmetric. ` `#include ` `#define MAX 1000 ` `using` `namespace` `std; ` ` `  `void` `checkHV(``int` `arr[][MAX], ``int` `N, ``int` `M) ` `{ ` `    ``// Initializing as both horizontal and vertical ` `    ``// symmetric. ` `    ``bool` `horizontal = ``true``, vertical = ``true``; ` ` `  `    ``// Checking for Horizontal Symmetry.  We compare ` `    ``// first row with last row, second row with second ` `    ``// last row and so on. ` `    ``for` `(``int` `i = 0, k = N - 1; i < N / 2; i++, k--) { ` `        ``// Checking each cell of a column. ` `        ``for` `(``int` `j = 0; j < M; j++) { ` `            ``// check if every cell is identical ` `            ``if` `(arr[i][j] != arr[k][j]) { ` `                ``horizontal = ``false``; ` `                ``break``; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Checking for Vertical Symmetry.  We compare ` `    ``// first column with last column, second xolumn ` `    ``// with second last column and so on. ` `    ``for` `(``int` `i = 0, k = M - 1; i < M / 2; i++, k--) { ` `        ``// Checking each cell of a row. ` `        ``for` `(``int` `j = 0; j < N; j++) { ` `            ``// check if every cell is identical ` `            ``if` `(arr[i][j] != arr[k][j]) { ` `                ``vertical = ``false``; ` `                ``break``; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``if` `(!horizontal && !vertical) ` `        ``cout << ``"NO\n"``; ` `    ``else` `if` `(horizontal && !vertical) ` `        ``cout << ``"HORIZONTAL\n"``; ` `    ``else` `if` `(vertical && !horizontal) ` `        ``cout << ``"VERTICAL\n"``; ` `    ``else` `        ``cout << ``"BOTH\n"``; ` `} ` ` `  `// Driven Program ` `int` `main() ` `{ ` `    ``int` `mat[MAX][MAX] = { { 1, 0, 1 }, ` `                          ``{ 0, 0, 0 }, ` `                          ``{ 1, 0, 1 } }; ` ` `  `    ``checkHV(mat, 3, 3); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program to find if ` `// a matrix is symmetric. ` `import` `java.io.*; ` ` `  `public` `class` `GFG { ` ` `  `    ``static` `void` `checkHV(``int``[][] arr, ``int` `N, ` `                        ``int` `M) ` `    ``{ ` ` `  `        ``// Initializing as both horizontal ` `        ``// and vertical symmetric. ` `        ``boolean` `horizontal = ``true``; ` `        ``boolean` `vertical = ``true``; ` ` `  `        ``// Checking for Horizontal Symmetry. ` `        ``// We compare first row with last ` `        ``// row, second row with second ` `        ``// last row and so on. ` `        ``for` `(``int` `i = ``0``, k = N - ``1``; ` `             ``i < N / ``2``; i++, k--) { ` ` `  `            ``// Checking each cell of a column. ` `            ``for` `(``int` `j = ``0``; j < M; j++) { ` `                ``// check if every cell is identical ` `                ``if` `(arr[i][j] != arr[k][j]) { ` `                    ``horizontal = ``false``; ` `                    ``break``; ` `                ``} ` `            ``} ` `        ``} ` ` `  `        ``// Checking for Vertical Symmetry. We compare ` `        ``// first column with last column, second xolumn ` `        ``// with second last column and so on. ` `        ``for` `(``int` `i = ``0``, k = M - ``1``; ` `             ``i < M / ``2``; i++, k--) { ` ` `  `            ``// Checking each cell of a row. ` `            ``for` `(``int` `j = ``0``; j < N; j++) { ` `                ``// check if every cell is identical ` `                ``if` `(arr[i][j] != arr[k][j]) { ` `                    ``horizontal = ``false``; ` `                    ``break``; ` `                ``} ` `            ``} ` `        ``} ` ` `  `        ``if` `(!horizontal && !vertical) ` `            ``System.out.println(``"NO"``); ` ` `  `        ``else` `if` `(horizontal && !vertical) ` `            ``System.out.println(``"HORIZONTAL"``); ` ` `  `        ``else` `if` `(vertical && !horizontal) ` `            ``System.out.println(``"VERTICAL"``); ` ` `  `        ``else` `            ``System.out.println(``"BOTH"``); ` `    ``} ` ` `  `    ``// Driver Code ` `    ``static` `public` `void` `main(String[] args) ` `    ``{ ` `        ``int``[][] mat = { { ``1``, ``0``, ``1` `}, ` `                        ``{ ``0``, ``0``, ``0` `}, ` `                        ``{ ``1``, ``0``, ``1` `} }; ` ` `  `        ``checkHV(mat, ``3``, ``3``); ` `    ``} ` `} ` ` `  `// This code is contributed by vt_m. `

## Python3

 `# Python3 program to find if a matrix is symmetric. ` `MAX` `=` `1000` ` `  `def` `checkHV(arr, N, M): ` `     `  `    ``# Initializing as both horizontal and vertical ` `    ``# symmetric. ` `    ``horizontal ``=` `True` `    ``vertical ``=` `True` `     `  `    ``# Checking for Horizontal Symmetry. We compare ` `    ``# first row with last row, second row with second ` `    ``# last row and so on. ` `    ``i ``=` `0` `    ``k ``=` `N ``-` `1` `    ``while``(i < N ``/``/` `2``): ` `         `  `        ``# Checking each cell of a column. ` `        ``for` `j ``in` `range``(M): ` `             `  `            ``# check if every cell is identical ` `            ``if` `(arr[i][j] !``=` `arr[k][j]): ` `                ``horizontal ``=` `False` `                ``break` `        ``i ``+``=` `1` `        ``k ``-``=` `1` `         `  `    ``# Checking for Vertical Symmetry. We compare ` `    ``# first column with last column, second xolumn ` `    ``# with second last column and so on. ` `    ``i ``=` `0` `    ``k ``=` `M ``-` `1` `    ``while``(i < M ``/``/` `2``): ` `         `  `        ``# Checking each cell of a row. ` `        ``for` `j ``in` `range``(N): ` `             `  `            ``# check if every cell is identical ` `            ``if` `(arr[i][j] !``=` `arr[k][j]): ` `                ``vertical ``=` `False` `                ``break` `        ``i ``+``=` `1` `        ``k ``-``=` `1` `         `  `    ``if` `(``not` `horizontal ``and` `not` `vertical): ` `        ``print``(``"NO"``) ` `    ``elif` `(horizontal ``and` `not` `vertical): ` `        ``print``(``"HORIZONTAL"``) ` `    ``elif` `(vertical ``and` `not` `horizontal): ` `        ``print``(``"VERTICAL"``) ` `    ``else``: ` `        ``print``(``"BOTH"``) ` `         `  `# Driver code ` `mat ``=` `[[``1``, ``0``, ``1``],[ ``0``, ``0``, ``0``],[``1``, ``0``, ``1``]] ` ` `  `checkHV(mat, ``3``, ``3``) ` ` `  `# This code is contributed by shubhamsingh10 `

## C#

 `// C# program to find if ` `// a matrix is symmetric. ` `using` `System; ` ` `  `public` `class` `GFG { ` ` `  `    ``static` `void` `checkHV(``int``[, ] arr, ``int` `N, ` `                        ``int` `M) ` `    ``{ ` `        ``// Initializing as both horizontal ` `        ``// and vertical symmetric. ` `        ``bool` `horizontal = ``true``; ` `        ``bool` `vertical = ``true``; ` ` `  `        ``// Checking for Horizontal Symmetry. ` `        ``// We compare first row with last ` `        ``// row, second row with second ` `        ``// last row and so on. ` `        ``for` `(``int` `i = 0, k = N - 1; ` `             ``i < N / 2; i++, k--) { ` ` `  `            ``// Checking each cell of a column. ` `            ``for` `(``int` `j = 0; j < M; j++) { ` `                ``// check if every cell is identical ` `                ``if` `(arr[i, j] != arr[k, j]) { ` `                    ``horizontal = ``false``; ` `                    ``break``; ` `                ``} ` `            ``} ` `        ``} ` ` `  `        ``// Checking for Vertical Symmetry. We compare ` `        ``// first column with last column, second xolumn ` `        ``// with second last column and so on. ` `        ``for` `(``int` `i = 0, k = M - 1; ` `             ``i < M / 2; i++, k--) { ` ` `  `            ``// Checking each cell of a row. ` `            ``for` `(``int` `j = 0; j < N; j++) { ` `                ``// check if every cell is identical ` `                ``if` `(arr[i, j] != arr[k, j]) { ` `                    ``horizontal = ``false``; ` `                    ``break``; ` `                ``} ` `            ``} ` `        ``} ` ` `  `        ``if` `(!horizontal && !vertical) ` `            ``Console.WriteLine(``"NO"``); ` ` `  `        ``else` `if` `(horizontal && !vertical) ` `            ``Console.WriteLine(``"HORIZONTAL"``); ` ` `  `        ``else` `if` `(vertical && !horizontal) ` `            ``Console.WriteLine(``"VERTICAL"``); ` ` `  `        ``else` `            ``Console.WriteLine(``"BOTH"``); ` `    ``} ` ` `  `    ``// Driver Code ` `    ``static` `public` `void` `Main() ` `    ``{ ` `        ``int``[, ] mat = { { 1, 0, 1 }, ` `                        ``{ 0, 0, 0 }, ` `                        ``{ 1, 0, 1 } }; ` ` `  `        ``checkHV(mat, 3, 3); ` `    ``} ` `} ` ` `  `// This code is contributed by vt_m. `

## PHP

 ` `

Output :

```BOTH
```

Time Complexity: O(N*M).

This article is contributed by Anuj Chauhan. 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.

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

Article Tags :
Practice Tags :

1

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.