# Check if the given chessboard is valid or not

Given an 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 the second is invalid.

Examples:

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

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

Observe, on a chess board, every adjacent pair of cells is painted in a 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.

Pseudocode:

```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;
}```

Implementation:

## 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[2][2] = { { 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` `?>`

## Javascript

 ``

Output

`Yes`

Time complexity: O(N^2) for given an N*N chessboard
Auxiliary space: O(1)

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

## C++

 `#include ` `using` `namespace` `std;` `bool` `checkBoard(vector> board)` `{` `    ``int` `base = board[0][0];` `    ``bool` `flag = ``true``;` ` `  `    ``for``(``int` `i = 0; i < board.size(); i++)` `    ``{` `        ``for``( ``int` `j = 0; j < board[i].size(); j++)` `        ``{` `            ``if``(( i + j ) % 2 == 0)` `            ``{` `                ``if``( board[i][j] != base )` `                ``{` `                    ``return` `false``;` `                ``}` `            ``}` `            ``else` `            ``{` `                ``if` `(board[i][j] == base)` `                ``{` `                    ``return` `false``;` `                ``}` `            ``}` `        ``}` `    ``}` `    ``return` `true``;` `}` `int` `main()` `{` `    ``vector> board1={{0, 1}, ` `                                ``{1, 0}};` `                    `  `    ``vector> board2={{1, 0, 1},` `                                ``{0, 1, 0},` `                                ``{1, 0, 1}};` `                    `  `    ``vector> board3={{1, 0, 1},` `                                ``{0, 1, 0},` `                                ``{1, 1, 1}};` ` `  `    ``if``(checkBoard(board1))` `    ``cout << ``"true\n"``;` `    ``else` `    ``cout << ``"false\n"``;` `    `  `    ``if``(checkBoard(board2))` `    ``cout << ``"true\n"``;` `    ``else` `    ``cout << ``"false\n"``;` `    `  `    ``if``(checkBoard(board3))` `    ``cout << ``"true\n"``;` `    ``else` `    ``cout << ``"false\n"``;` `    `  `    ``return` `0;` `}` `//This code is contributed by aditya942003patil`

## Java

 `/*package whatever //do not write package name here */` `import` `java.io.*;` `class` `GFG ` `{`   `  ``static` `boolean` `checkBoard(``int``[][] board)` `  ``{` `    ``int` `base = board[``0``][``0``];` `    ``boolean` `flag = ``true``;`   `    ``for``(``int` `i = ``0``; i < board.length; i++)` `    ``{` `      ``for``( ``int` `j = ``0``; j < board[i].length; j++)` `      ``{` `        ``if``(( i + j ) % ``2` `== ``0``)` `        ``{` `          ``if``( board[i][j] != base )` `          ``{` `            ``return` `false``;` `          ``}` `        ``}` `        ``else` `        ``{` `          ``if` `(board[i][j] == base)` `          ``{` `            ``return` `false``;` `          ``}` `        ``}` `      ``}` `    ``}` `    ``return` `true``;` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `main (String[] args) {`   `    ``int``[][] board1={{``0``, ``1``}, {``1``, ``0``}};` `    ``int``[][] board2={{``1``, ``0``, ``1``},{``0``, ``1``, ``0``},{``1``, ``0``, ``1``}};` `    ``int``[][] board3={{``1``, ``0``, ``1``},{``0``, ``1``, ``0``},{``1``, ``1``, ``1``}};`   `    ``System.out.println(checkBoard(board1));` `    ``System.out.println(checkBoard(board2));` `    ``System.out.println(checkBoard(board3));` `  ``}` `}`   `// This code is contributed by rag2127`

## Python3

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

## C#

 `using` `System;` `public` `class` `GFG` `{`   `  ``static` `bool` `checkBoard(``int``[,] board)` `  ``{` `    ``int` `Base = board[0, 0];`   `    ``for``(``int` `i = 0; i < board.GetLength(0); i++)` `    ``{` `      ``for``( ``int` `j = 0; j < board.GetLength(1); j++)` `      ``{` `        ``if``(( i + j ) % 2 == 0)` `        ``{` `          ``if``( board[i, j] != Base )` `          ``{` `            ``return` `false``;` `          ``}` `        ``}` `        ``else` `        ``{` `          ``if` `(board[i, j] == Base)` `          ``{` `            ``return` `false``;` `          ``}` `        ``}` `      ``}` `    ``}` `    ``return` `true``;` `  ``}`   `  ``// Driver code` `  ``static` `public` `void` `Main ()` `  ``{` `    ``int``[,] board1 = {{0, 1}, {1, 0}};` `    ``int``[,] board2 = {{1, 0, 1},{0, 1, 0},{1, 0, 1}};` `    ``int``[,] board3 = {{1, 0, 1},{0, 1, 0},{1, 1, 1}};`   `    ``Console.WriteLine(checkBoard(board1));` `    ``Console.WriteLine(checkBoard(board2));` `    ``Console.WriteLine(checkBoard(board3));` `  ``}` `}`   `// This code is contributed by avanitrachhadiya2155`

## Javascript

 ``

Output

```true
true
false```

Time complexity: O(N^2) for given an N*N chessboard
Auxiliary space: O(1)

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next