# Check if the given chessboard is valid or not

Given a NXN chessboard. The task is to check if the given chessboard is valid or not. A chess board is considered valid if every 2 adjacent cells are painted with different color. Two cells are considered adjacent if they share a boundary. First chessboard is valid whereas second is invalid.

Examples:

```Input : N = 2
C = {
{ 1, 0 },
{ 0, 1 }
}
Output : Yes

Input : N = 2
C = {
{ 0, 0 },
{ 0, 0 }
}
Output : No
```

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

Observe, on a chess board, every adjacent pair of cells is painted in different color.
So, for each cell (i, j), check whether the adjacent cells i.e
(i + 1, j), (i -1, j), (i, j + 1), (i, j – 1) is painted with different color than (i, j) or not.

Psedocode:

```int X[] = {0, -1, 0, 1};
int Y[] = {1, 0, -1, 0};

bool validateConfiguration(int M[N][N])
{
bool isValid = true;
for (int i = 0; i < N; i++)
{
for (int j = 0; j < N; j++)
{
for (int k = 0; k < 4; k++)
{
int newX = i + X[k];
int newY = j + Y[k];
if (newX < N && newY < N && newX >= 0 &&
newY >= 0 && M[newX][newY] == M[i][j])
{
isValid = false;
}
}
}
}
return isValid;
}```

Below is the implemantation of this approach:

## C++

 `#include ` `using` `namespace` `std; ` `#define MAX 2 ` ` `  `// Check if the given chess board is valid or not. ` `bool` `isValid(``int` `c[][MAX], ``int` `n) ` `{ ` `    ``int` `X[] = { 0, -1, 0, 1 }; ` `    ``int` `Y[] = { 1, 0, -1, 0 }; ` `    ``bool` `isValid = ``true``; ` ` `  `    ``// Traversing each cell of the chess board. ` `    ``for` `(``int` `i = 0; i < n; i++) { ` `        ``for` `(``int` `j = 0; j < n; j++) { ` ` `  `            ``// for each adjacent cells ` `            ``for` `(``int` `k = 0; k < 4; k++) { ` `                ``int` `newX = i + X[k]; ` `                ``int` `newY = j + Y[k]; ` ` `  `                ``// checking if they have different color ` `                ``if` `(newX < n && newY < n && newX >= 0 &&  ` `                    ``newY >= 0 && c[newX][newY] == c[i][j]) { ` `                    ``isValid = ``false``; ` `                ``} ` `            ``} ` `        ``} ` `    ``} ` `    ``return` `isValid; ` `} ` ` `  `// Driven Program ` `int` `main() ` `{ ` `    ``int` `n = 2; ` `    ``int` `c = { { 1, 0 }, ` `                    ``{ 0, 1 } }; ` ` `  `    ``(isValid(c, n)) ? (cout << ``"Yes"``) : (cout << ``"No"``); ` `    ``return` `0; ` `} `

## Java

 `// Check if the given chess  ` `// board is valid or not ` `class` `GFG  ` `{ ` `static` `int` `MAX = ``2``; ` ` `  `static` `boolean` `isValid(``int` `c[][], ``int` `n) ` `{ ` `    ``int` `X[] = { ``0``, -``1``, ``0``, ``1` `}; ` `    ``int` `Y[] = { ``1``, ``0``, -``1``, ``0` `}; ` `    ``boolean` `isValid = ``true``; ` ` `  `    ``// Traversing each cell  ` `    ``// of the chess board. ` `    ``for` `(``int` `i = ``0``; i < n; i++)  ` `    ``{ ` `        ``for` `(``int` `j = ``0``; j < n; j++) ` `        ``{ ` ` `  `            ``// for each adjacent cells ` `            ``for` `(``int` `k = ``0``; k < ``4``; k++)  ` `            ``{ ` `                ``int` `newX = i + X[k]; ` `                ``int` `newY = j + Y[k]; ` ` `  `                ``// checking if they have ` `                ``// different color ` `                ``if` `(newX < n && newY < n &&  ` `                    ``newX >= ``0` `&& newY >= ``0` `&& ` `                    ``c[newX][newY] == c[i][j]) ` `                ``{ ` `                    ``isValid = ``false``; ` `                ``} ` `            ``} ` `        ``} ` `    ``} ` `    ``return` `isValid; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main(String[] args)  ` `{ ` `    ``int` `n = ``2``; ` `    ``int``[][] c = {{ ``1``, ``0` `}, ` `                 ``{ ``0``, ``1` `}}; ` ` `  `    ``if` `(isValid(c, n))  ` `        ``System.out.println(``"Yes"``); ` `    ``else` `        ``System.out.println(``"No"``); ` `} ` `}  ` ` `  `// This code is contributed by ChitraNayal `

## Python 3

 `# Python 3 Program to Check  ` `# if the given chessboard ` `# is valid or not ` `MAX` `=` `2` ` `  `# Check if the given chess ` `# board is valid or not. ` `def` `isValid(c, n) : ` ` `  `    ``X ``=` `[ ``0``, ``-``1``, ``0``, ``1``] ` `    ``Y ``=` `[ ``1``, ``0``, ``-``1``, ``0``] ` `    ``isValid ``=` `True` ` `  `    ``# Traversing each cell  ` `    ``# of the chess board.  ` `    ``for` `i ``in` `range``(n) : ` `        ``for` `j ``in` `range``(n) : ` `             `  `            ``# for each adjacent cells ` `            ``for` `k ``in` `range``(n) : ` `                ``newX ``=` `i ``+` `X[k] ` `                ``newY ``=` `j ``+` `Y[k] ` ` `  `                ``# checking if they have ` `                ``# different color  ` `                ``if` `(newX < n ``and` `newY < n ``and`  `                    ``newX >``=` `0` `and` `newY >``=` `0` `and`  `                    ``c[newX][newY] ``=``=` `c[i][j]) : ` `                    ``isValid ``=` `false ` ` `  `    ``return` `isValid ` `     `  `# Driver Code ` `if` `__name__ ``=``=` `"__main__"` `: ` `    ``n ``=` `2` `    ``c ``=` `[ [``1``, ``0``], ` `          ``[``0``, ``1``] ] ` ` `  `    ``if` `isValid(c, n) : ` `        ``print``(``"Yes"``) ` ` `  `    ``else` `: ` `        ``print``(``"No"``) ` `                     `  `# This code is contributed  ` `# by ANKITRAI1 `

## C#

 `// Check if the given chess ` `// board is valid or not. ` `using` `System; ` ` `  `class` `GFG  ` `{ ` ` `  `static` `bool` `isValid(``int``[,] c, ``int` `n) ` `{ ` `    ``int``[] X = { 0, -1, 0, 1 }; ` `    ``int``[] Y = { 1, 0, -1, 0 }; ` `    ``bool` `isValid = ``true``; ` ` `  `    ``// Traversing each cell  ` `    ``// of the chess board. ` `    ``for` `(``int` `i = 0; i < n; i++)  ` `    ``{ ` `        ``for` `(``int` `j = 0; j < n; j++)  ` `        ``{ ` ` `  `            ``// for each adjacent cells ` `            ``for` `(``int` `k = 0; k < 4; k++)  ` `            ``{ ` `                ``int` `newX = i + X[k]; ` `                ``int` `newY = j + Y[k]; ` ` `  `                ``// checking if they have different color ` `                ``if` `(newX < n && newY < n &&  ` `                    ``newX >= 0 && newY >= 0 &&  ` `                    ``c[newX, newY] == c[i, j])  ` `                ``{ ` `                    ``isValid = ``false``; ` `                ``} ` `            ``} ` `        ``} ` `    ``} ` `    ``return` `isValid; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main()  ` `{ ` `    ``int` `n = 2; ` `    ``int``[,] c = {{ 1, 0 }, ` `                ``{ 0, 1 }}; ` ` `  `    ``if` `(isValid(c, n))  ` `        ``Console.Write(``"Yes"``); ` `    ``else` `        ``Console.Write(``"No"``); ` `} ` `}  ` ` `  `// This code is contributed by ChitraNayal `

## PHP

 `= 0 && ``\$newY` `>= 0 &&  ` `                    ``\$c``[``\$newX``][``\$newY``] == ``\$c``[``\$i``][``\$j``])  ` `                ``{ ` `                    ``\$isValid` `= false; ` `                ``} ` `            ``} ` `        ``} ` `    ``} ` `    ``return` `\$isValid``; ` `} ` ` `  `// Driver Code ` `\$n` `= 2; ` `\$c` `= ``array``(``array``(1, 0), ` `           ``array``(0, 1)); ` ` `  `echo` `(isValid(``\$c``, ``\$n``)) ? ``"Yes"` `: ``"No"``; ` ` `  `// This code is contributed by ChitraNayal ` `?> `

Output :

`Yes`

A simpler approach would be to check if the cells with even sums are of the same color.

 `# Write Python3 code here ` `def` `checkBoard(board) : ` `    ``base ``=` `board[``0``][``0``] ` `    ``flag ``=` `True` `    ``for` `i ``in` `range``(``len``(board)) : ` `        ``for` `j ``in` `range``(``len``(board[i])) : ` `            ``if``( i ``+` `j ) ``%` `2` `=``=` `0` `: ` `                ``if` `board[i][j] !``=` `base : ` `                    ``return` `False` `            ``else` `: ` `                ``if` `board[i][j] ``=``=` `base : ` `                    ``return` `False` `    ``return` `True` `     `  `board1 ``=` `[[``0``, ``1``], [``1``, ``0``]] ` `board2 ``=` `[[``1``, ``0``, ``1``], [``0``, ``1``, ``0``], [``1``, ``0``, ``1``]] ` `board3 ``=` `[[``1``, ``0``, ``1``], [``0``, ``1``, ``0``], [``1``, ``1``, ``1``]] ` `print``(checkBoard(board1)) ` `print``(checkBoard(board2)) ` `print``(checkBoard(board3)) `

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

Be the First to upvote.

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