# Check if the given chessboard is valid or not

• Difficulty Level : Basic
• Last Updated : 23 Sep, 2022

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)

My Personal Notes arrow_drop_up