# Check if any King is unsafe on the Chessboard or not

• Difficulty Level : Hard
• Last Updated : 18 Oct, 2021

Given a matrix board[][] consisting of the characters K or k, Q or q, B or b, N or n, R or r, and P or p (Upper case white and lower case black) representing the King, the Queen, the Bishop, the Knight, the Rook, and Pawns of Black and White color respectively, and empty spaces indicated by ‘-‘, the task is to check which king (black of white) is unsafe, i.e. if it is under attack (can be eliminated) by any of the other pieces and print the answer accordingly.
Note: If both kings are safe then output “No King in danger”.
Examples:

```Input:
board[][] = {{- - - k - - - -},
{p p p - p p p p},
{- - - - - b - -},
{- - - R - - - -},
{- - - - - - - -},
{- - - - - - - -},
{P - P P P P P P},
{K - - - - - - - }}
Output:White King in danger
Explanation: Black bishop can attack the white king.

Input:
board[][] = {{- - k - - - - -},
{p p p - p p p p},
{- - - - - - b -},
{- - - R - - - -},
{- - - - - - - -},
{- - - - - - - -}
{P - P P P P P P},
{K - - - - - - -}}
Output: No King in danger```

Approach:
The approach is to check the moves of each and every piece on the chessboard:

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

1. Check for the position of both white and black kings.
2. For each king, check Rook, bishops, knight, king, Queen, Pawn of the opposite color, whether they are attacking the king or not.
3. Checking for attack by the queen is a combination of checking attacks by rooks and bishops. If any of the conditions are true then the queen will attack.
4. If none of the attack conditions are satisfied for any of the two kings, then there is no danger to both the king.
5. Otherwise, print the answer for the king whose unsafe condition is satisfied.

Below is the implementation of this approach.

## C++

 `// C++ program to implement the ` `// above approach` `#include ` `using` `namespace` `std;`   `// Check if the indices ` `// are within the matrix ` `// or not` `bool` `inBounds(``int` `i, ` `              ``int` `j)` `{` `  ``// Checking boundary ` `  ``// conditions` `  ``return` `i >= 0 && i < 8 && ` `         ``j >= 0 && j < 8;` `}`   `bool` `lookFork(``char` `board[], ` `              ``char` `c, ``int` `i, ` `              ``int` `j)` `{` `  ``// Store all possible moves ` `  ``// of the king` `  ``int` `x[] = {-1, -1, -1, 0, ` `             ``0, 1, 1, 1};` `  ``int` `y[] = {-1, 0, 1, -1,` `             ``1, -1, 0, 1};`   `  ``for` `(``int` `k = 0; k < 8; k++) ` `  ``{` `    ``// incrementing index ` `    ``// values` `    ``int` `m = i + x[k];` `    ``int` `n = j + y[k];`   `    ``// checking boundary ` `    ``// conditions and ` `    ``// character match` `    ``if` `(inBounds(m, n) && ` `        ``board[m][n] == c)` `      ``return` `true``;` `  ``}` `  ``return` `false``;` `}`   `// Function to check if bishop ` `// can attack the king` `bool` `lookForb(``char` `board[], ` `              ``char` `c, ``int` `i, ` `              ``int` `j)` `{` `  ``// Check the lower right ` `  ``// diagonal` `  ``int` `k = 0;` `  ``while` `(inBounds(i + ++k, j + k)) ` `  ``{` `    ``if` `(board[i + k][j + k] == c)` `      ``return` `true``;` `    ``if` `(board[i + k][j + k] != ``'-'``)` `      ``break``;` `  ``}`   `  ``// Check the lower left diagonal` `  ``k = 0;` `  ``while` `(inBounds(i + ++k, j - k)) ` `  ``{`   `    ``if` `(board[i + k][j - k] == c)` `      ``return` `true``;` `    ``if` `(board[i + k][j - k] != ``'-'``)` `      ``break``;` `  ``}`   `  ``// Check the upper right ` `  ``// diagonal` `  ``k = 0;` `  ``while` `(inBounds(i - ++k, j + k)) ` `  ``{` `    ``if` `(board[i - k][j + k] == c)` `      ``return` `true``;` `    ``if` `(board[i - k][j + k] != ``'-'``)` `      ``break``;` `  ``}`   `  ``// Check the upper left ` `  ``// diagonal` `  ``k = 0;` `  ``while` `(inBounds(i - ++k, j - k))` `  ``{` `    ``if` `(board[i - k][j - k] == c)` `      ``return` `true``;` `    ``if` `(board[i - k][j - k] != ``'-'``)` `      ``break``;` `  ``}`   `  ``return` `false``;` `}`   `// Check if` `bool` `lookForr(``char` `board[], ` `              ``char` `c, ``int` `i, ` `              ``int` `j)` `{` `  ``// Check downwards` `  ``int` `k = 0;` `  ``while` `(inBounds(i + ++k, j)) ` `  ``{` `    ``if` `(board[i + k][j] == c)` `      ``return` `true``;` `    ``if` `(board[i + k][j] != ``'-'``)` `      ``break``;` `  ``}`   `  ``// Check upwards` `  ``k = 0;` `  ``while` `(inBounds(i + --k, j)) ` `  ``{` `    ``if` `(board[i + k][j] == c)` `      ``return` `true``;` `    ``if` `(board[i + k][j] != ``'-'``)` `      ``break``;` `  ``}`   `  ``// Check right` `  ``k = 0;` `  ``while` `(inBounds(i, j + ++k)) ` `  ``{` `    ``if` `(board[i][j + k] == c)` `      ``return` `true``;` `    ``if` `(board[i][j + k] != ``'-'``)` `      ``break``;` `  ``}`   `  ``// Check left` `  ``k = 0;` `  ``while` `(inBounds(i, j + --k)) ` `  ``{` `    ``if` `(board[i][j + k] == c)` `      ``return` `true``;` `    ``if` `(board[i][j + k] != ``'-'``)` `      ``break``;` `  ``}` `  ``return` `false``;` `}`   `// Function to check if Queen ` `// can attack the King` `bool` `lookForq(``char` `board[], ` `              ``char` `c, ``int` `i, ` `              ``int` `j)` `{` `  ``// Queen's moves are a combination` `  ``// of both the Bishop and the Rook` `  ``if` `(lookForb(board, c, i, j) || ` `      ``lookForr(board, c, i, j))` `    ``return` `true``;`   `  ``return` `false``;` `}`   `// Check if the knight can ` `// attack the king` `bool` `lookForn(``char` `board[], ` `              ``char` `c, ``int` `i, ` `              ``int` `j)` `{` `  ``// All possible moves of` `  ``// the knight` `  ``int` `x[] = {2, 2, -2, -2, ` `             ``1, 1, -1, -1};` `  ``int` `y[] = {1, -1, 1, -1, ` `             ``2, -2, 2, -2};`   `  ``for` `(``int` `k = 0; k < 8; k++) ` `  ``{` `    ``// Incrementing index ` `    ``// values` `    ``int` `m = i + x[k];` `    ``int` `n = j + y[k];`   `    ``// Checking boundary conditions` `    ``// and character match` `    ``if` `(inBounds(m, n) && ` `        ``board[m][n] == c)` `      ``return` `true``;` `  ``}` `  ``return` `false``;` `}`   `// Function to check if pawn ` `// can attack the king` `bool` `lookForp(``char` `board[], ` `              ``char` `c, ``int` `i, ` `              ``int` `j)` `{` `  ``char` `lookFor;` `  ``if` `(``isupper``(c)) ` `  ``{` `    ``// Check for white pawn` `    ``lookFor = ``'P'``;` `    ``if` `(inBounds(i + 1, j - 1) && ` `        ``board[i + 1][j - 1] == lookFor)` `      ``return` `true``;`   `    ``if` `(inBounds(i + 1, j + 1) && ` `        ``board[i + 1][j + 1] == lookFor)` `      ``return` `true``;` `  ``}` `  ``else` `  ``{` `    ``// Check for black pawn` `    ``lookFor = ``'p'``;` `    ``if` `(inBounds(i - 1, j - 1) && ` `        ``board[i - 1][j - 1] == lookFor)` `      ``return` `true``;` `    ``if` `(inBounds(i - 1, j + 1) && ` `        ``board[i - 1][j + 1] == lookFor)` `      ``return` `true``;` `  ``}` `  ``return` `false``;` `}`   `// Function to check if any ` `// of the two kings is unsafe` `// or not` `int` `checkBoard(``char` `board[])` `{` `  ``// Find the position of both ` `  ``// the kings` `  ``for` `(``int` `i = 0; i < 8; i++) ` `  ``{` `    ``for` `(``int` `j = 0; j < 8; j++) ` `    ``{` `      ``// Check for all pieces which` `      ``// can attack White King` `      ``if` `(board[i][j] == ``'k'``) ` `      ``{` `        ``// Check for Knight` `        ``if` `(lookForn(board, ` `                     ``'N'``, i, j))` `          ``return` `1;`   `        ``// Check for Pawn` `        ``if` `(lookForp(board, ` `                     ``'P'``, i, j))` `          ``return` `1;`   `        ``// Check for Rook` `        ``if` `(lookForr(board, ` `                     ``'R'``, i, j))` `          ``return` `1;`   `        ``// Check for Bishop` `        ``if` `(lookForb(board, ` `                     ``'B'``, i, j))` `          ``return` `1;`   `        ``// Check for Queen` `        ``if` `(lookForq(board, ` `                     ``'Q'``, i, j))` `          ``return` `1;`   `        ``// Check for King` `        ``if` `(lookFork(board, ` `                     ``'K'``, i, j))` `          ``return` `1;` `      ``}`   `      ``// Check for all pieces which` `      ``// can attack Black King` `      ``if` `(board[i][j] == ``'K'``) ` `      ``{` `        ``// Check for Knight` `        ``if` `(lookForn(board, ` `                     ``'n'``, i, j))` `          ``return` `2;`   `        ``// Check for Pawn` `        ``if` `(lookForp(board, ` `                     ``'p'``, i, j))` `          ``return` `2;`   `        ``// Check for Rook` `        ``if` `(lookForr(board, ` `                     ``'r'``, i, j))` `          ``return` `2;`   `        ``// Check for Bishop` `        ``if` `(lookForb(board, ` `                     ``'b'``, i, j))` `          ``return` `2;`   `        ``// Check for Queen` `        ``if` `(lookForq(board, ` `                     ``'q'``, i, j))` `          ``return` `2;`   `        ``// Check for King` `        ``if` `(lookFork(board, ` `                     ``'k'``, i, j))` `          ``return` `2;` `      ``}` `    ``}` `  ``}` `  ``return` `0;` `}`   `// Driver Code` `int` `main()` `{` `  ``// Chessboard instance` `  ``char` `board[] = {{``'-'``, ``'-'``, ``'-'``, ``'k'``, ` `                      ``'-'``, ``'-'``, ``'-'``, ``'-'``},` `                     ``{``'p'``, ``'p'``, ``'p'``, ``'-'``, ` `                      ``'p'``, ``'p'``, ``'p'``, ``'p'``},` `                     ``{``'-'``, ``'-'``, ``'-'``, ``'-'``, ` `                      ``'-'``, ``'b'``, ``'-'``, ``'-'``},` `                     ``{ ``'-'``, ``'-'``, ``'-'``, ``'R'``, ` `                      ``'-'``, ``'-'``, ``'-'``, ``'-'``},` `                     ``{``'-'``, ``'-'``, ``'-'``, ``'-'``, ` `                      ``'-'``, ``'-'``, ``'-'``, ``'-'``}, ` `                     ``{``'-'``, ``'-'``, ``'-'``, ``'-'``, ` `                      ``'-'``, ``'-'``, ``'-'``, ``'-'``}, ` `                     ``{``'P'``, ``'-'``, ``'P'``, ``'P'``, ` `                      ``'P'``, ``'P'``, ``'P'``, ``'P'``}, ` `                     ``{``'K'``, ``'-'``, ``'-'``, ``'-'``, ` `                      ``'-'``, ``'-'``, ``'-'``, ``'-'``}};`   `  ``if` `(checkBoard(board) == 0)` `    ``cout << (``"No king in danger"``);`   `  ``else` `if` `(checkBoard(board) == 1)` `    ``cout << (``"White king in danger"``);`   `  ``else` `    ``cout << (``"Black king in danger"``);` `}`   `// This code is contributed by Chitranyal`

## Java

 `public` `class` `Gfg {`   `    ``// Function to check if any of the two` `    ``// kings is unsafe or not` `    ``private` `static` `int` `checkBoard(``char``[][] board)` `    ``{`   `        ``// Find the position of both the kings` `        ``for` `(``int` `i = ``0``; i < ``8``; i++) {` `            ``for` `(``int` `j = ``0``; j < ``8``; j++) {`   `                ``// Check for all pieces which` `                ``// can attack White King` `                ``if` `(board[i][j] == ``'k'``) {`   `                    ``// Check for Knight` `                    ``if` `(lookForn(board, ``'N'``, i, j))` `                        ``return` `1``;`   `                    ``// Check for Pawn` `                    ``if` `(lookForp(board, ``'P'``, i, j))` `                        ``return` `1``;`   `                    ``// Check for Rook` `                    ``if` `(lookForr(board, ``'R'``, i, j))` `                        ``return` `1``;`   `                    ``// Check for Bishop` `                    ``if` `(lookForb(board, ``'B'``, i, j))` `                        ``return` `1``;`   `                    ``// Check for Queen` `                    ``if` `(lookForq(board, ``'Q'``, i, j))` `                        ``return` `1``;`   `                    ``// Check for King` `                    ``if` `(lookFork(board, ``'K'``, i, j))` `                        ``return` `1``;` `                ``}`   `                ``// Check for all pieces which` `                ``// can attack Black King` `                ``if` `(board[i][j] == ``'K'``) {`   `                    ``// Check for Knight` `                    ``if` `(lookForn(board, ``'n'``, i, j))` `                        ``return` `2``;`   `                    ``// Check for Pawn` `                    ``if` `(lookForp(board, ``'p'``, i, j))` `                        ``return` `2``;`   `                    ``// Check for Rook` `                    ``if` `(lookForr(board, ``'r'``, i, j))` `                        ``return` `2``;`   `                    ``// Check for Bishop` `                    ``if` `(lookForb(board, ``'b'``, i, j))` `                        ``return` `2``;`   `                    ``// Check for Queen` `                    ``if` `(lookForq(board, ``'q'``, i, j))` `                        ``return` `2``;`   `                    ``// Check for King` `                    ``if` `(lookFork(board, ``'k'``, i, j))` `                        ``return` `2``;` `                ``}` `            ``}` `        ``}` `        ``return` `0``;` `    ``}`   `    ``private` `static` `boolean` `lookFork(``char``[][] board,` `                                    ``char` `c, ``int` `i, ``int` `j)` `    ``{`   `        ``// Store all possible moves of the king` `        ``int``[] x = { -``1``, -``1``, -``1``, ``0``, ``0``, ``1``, ``1``, ``1` `};` `        ``int``[] y = { -``1``, ``0``, ``1``, -``1``, ``1``, -``1``, ``0``, ``1` `};`   `        ``for` `(``int` `k = ``0``; k < ``8``; k++) {`   `            ``// incrementing index values` `            ``int` `m = i + x[k];` `            ``int` `n = j + y[k];`   `            ``// checking boundary conditions` `            ``// and character match` `            ``if` `(inBounds(m, n) && board[m][n] == c)` `                ``return` `true``;` `        ``}` `        ``return` `false``;` `    ``}`   `    ``// Function to check if Queen can attack the King` `    ``private` `static` `boolean` `lookForq(``char``[][] board,` `                                    ``char` `c, ``int` `i, ``int` `j)` `    ``{`   `        ``// Queen's moves are a combination` `        ``// of both the Bishop and the Rook` `        ``if` `(lookForb(board, c, i, j) || lookForr(board, c, i, j))` `            ``return` `true``;`   `        ``return` `false``;` `    ``}`   `    ``// Function to check if bishop can attack the king` `    ``private` `static` `boolean` `lookForb(``char``[][] board,` `                                    ``char` `c, ``int` `i, ``int` `j)` `    ``{`   `        ``// Check the lower right diagonal` `        ``int` `k = ``0``;` `        ``while` `(inBounds(i + ++k, j + k)) {`   `            ``if` `(board[i + k][j + k] == c)` `                ``return` `true``;` `            ``if` `(board[i + k][j + k] != ``'-'``)` `                ``break``;` `        ``}`   `        ``// Check the lower left diagonal` `        ``k = ``0``;` `        ``while` `(inBounds(i + ++k, j - k)) {`   `            ``if` `(board[i + k][j - k] == c)` `                ``return` `true``;` `            ``if` `(board[i + k][j - k] != ``'-'``)` `                ``break``;` `        ``}`   `        ``// Check the upper right diagonal` `        ``k = ``0``;` `        ``while` `(inBounds(i - ++k, j + k)) {`   `            ``if` `(board[i - k][j + k] == c)` `                ``return` `true``;` `            ``if` `(board[i - k][j + k] != ``'-'``)` `                ``break``;` `        ``}`   `        ``// Check the upper left diagonal` `        ``k = ``0``;` `        ``while` `(inBounds(i - ++k, j - k)) {`   `            ``if` `(board[i - k][j - k] == c)` `                ``return` `true``;` `            ``if` `(board[i - k][j - k] != ``'-'``)` `                ``break``;` `        ``}`   `        ``return` `false``;` `    ``}`   `    ``// Check if` `    ``private` `static` `boolean` `lookForr(``char``[][] board,` `                                    ``char` `c, ``int` `i, ``int` `j)` `    ``{`   `        ``// Check downwards` `        ``int` `k = ``0``;` `        ``while` `(inBounds(i + ++k, j)) {` `            ``if` `(board[i + k][j] == c)` `                ``return` `true``;` `            ``if` `(board[i + k][j] != ``'-'``)` `                ``break``;` `        ``}`   `        ``// Check upwards` `        ``k = ``0``;` `        ``while` `(inBounds(i + --k, j)) {` `            ``if` `(board[i + k][j] == c)` `                ``return` `true``;` `            ``if` `(board[i + k][j] != ``'-'``)` `                ``break``;` `        ``}`   `        ``// Check right` `        ``k = ``0``;` `        ``while` `(inBounds(i, j + ++k)) {` `            ``if` `(board[i][j + k] == c)` `                ``return` `true``;` `            ``if` `(board[i][j + k] != ``'-'``)` `                ``break``;` `        ``}`   `        ``// Check left` `        ``k = ``0``;` `        ``while` `(inBounds(i, j + --k)) {` `            ``if` `(board[i][j + k] == c)` `                ``return` `true``;` `            ``if` `(board[i][j + k] != ``'-'``)` `                ``break``;` `        ``}` `        ``return` `false``;` `    ``}`   `    ``// Check if the knight can attack the king` `    ``private` `static` `boolean` `lookForn(``char``[][] board,` `                                    ``char` `c, ``int` `i, ``int` `j)` `    ``{`   `        ``// All possible moves of the knight` `        ``int``[] x = { ``2``, ``2``, -``2``, -``2``, ``1``, ``1``, -``1``, -``1` `};` `        ``int``[] y = { ``1``, -``1``, ``1``, -``1``, ``2``, -``2``, ``2``, -``2` `};`   `        ``for` `(``int` `k = ``0``; k < ``8``; k++) {`   `            ``// Incrementing index values` `            ``int` `m = i + x[k];` `            ``int` `n = j + y[k];`   `            ``// Checking boundary conditions` `            ``// and character match` `            ``if` `(inBounds(m, n) && board[m][n] == c)` `                ``return` `true``;` `        ``}` `        ``return` `false``;` `    ``}`   `    ``// Function to check if pawn can attack the king` `    ``private` `static` `boolean` `lookForp(``char``[][] board,` `                                    ``char` `c, ``int` `i, ``int` `j)` `    ``{`   `        ``char` `lookFor;` `        ``if` `(Character.isUpperCase(c)) {`   `            ``// Check for white pawn` `            ``lookFor = ``'P'``;` `            ``if` `(inBounds(i + ``1``, j - ``1``)` `                ``&& board[i + ``1``][j - ``1``] == lookFor)` `                ``return` `true``;`   `            ``if` `(inBounds(i + ``1``, j + ``1``)` `                ``&& board[i + ``1``][j + ``1``] == lookFor)` `                ``return` `true``;` `        ``}` `        ``else` `{`   `            ``// Check for black pawn` `            ``lookFor = ``'p'``;` `            ``if` `(inBounds(i - ``1``, j - ``1``)` `                ``&& board[i - ``1``][j - ``1``] == lookFor)` `                ``return` `true``;` `            ``if` `(inBounds(i - ``1``, j + ``1``)` `                ``&& board[i - ``1``][j + ``1``] == lookFor)` `                ``return` `true``;` `        ``}` `        ``return` `false``;` `    ``}`   `    ``// Check if the indices are within` `    ``// the matrix or not` `    ``private` `static` `boolean` `inBounds(``int` `i, ``int` `j)` `    ``{`   `        ``// Checking boundary conditions` `        ``return` `i >= ``0` `&& i < ``8` `&& j >= ``0` `&& j < ``8``;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{`   `        ``// Chessboard instance` `        ``char``[][] board` `            ``= { { ``'-'``, ``'-'``, ``'-'``, ``'k'``, ``'-'``, ``'-'``, ``'-'``, ``'-'` `},` `                ``{ ``'p'``, ``'p'``, ``'p'``, ``'-'``, ``'p'``, ``'p'``, ``'p'``, ``'p'` `},` `                ``{ ``'-'``, ``'-'``, ``'-'``, ``'-'``, ``'-'``, ``'b'``, ``'-'``, ``'-'` `},` `                ``{ ``'-'``, ``'-'``, ``'-'``, ``'R'``, ``'-'``, ``'-'``, ``'-'``, ``'-'` `},` `                ``{ ``'-'``, ``'-'``, ``'-'``, ``'-'``, ``'-'``, ``'-'``, ``'-'``, ``'-'` `},` `                ``{ ``'-'``, ``'-'``, ``'-'``, ``'-'``, ``'-'``, ``'-'``, ``'-'``, ``'-'` `},` `                ``{ ``'P'``, ``'-'``, ``'P'``, ``'P'``, ``'P'``, ``'P'``, ``'P'``, ``'P'` `},` `                ``{ ``'K'``, ``'-'``, ``'-'``, ``'-'``, ``'-'``, ``'-'``, ``'-'``, ``'-'` `} };`   `        ``if` `(checkBoard(board) == ``0``)` `            ``System.out.println(``"No king in danger"``);`   `        ``else` `if` `(checkBoard(board) == ``1``)` `            ``System.out.println(``"White king in danger"``);`   `        ``else` `            ``System.out.println(``"Black king in danger"``);` `    ``}` `}`

## Python3

 `# Python3 program to implement the above approach`   `# Function to check if any of the two` `# kings is unsafe or not` `def` `checkBoard(board):` `  `  `    ``# Find the position of both the kings` `    ``for` `i ``in` `range``(``8``):` `        ``for` `j ``in` `range``(``8``):` `          `  `            ``# Check for all pieces which` `            ``# can attack White King` `            ``if` `board[i][j] ``=``=` `'k'``:` `              `  `                ``# Check for Knight` `                ``if` `lookForn(board, ``'N'``, i, j):` `                    ``return` `1`   `                ``# Check for Pawn` `                ``if` `lookForp(board, ``'P'``, i, j):` `                    ``return` `1`   `                ``# Check for Rook` `                ``if` `lookForr(board, ``'R'``, i, j):` `                    ``return` `1`   `                ``# Check for Bishop` `                ``if` `lookForb(board, ``'B'``, i, j):` `                    ``return` `1`   `                ``# Check for Queen` `                ``if` `lookForq(board, ``'Q'``, i, j):` `                    ``return` `1`   `                ``# Check for King` `                ``if` `lookFork(board, ``'K'``, i, j):` `                    ``return` `1`   `            ``# Check for all pieces which` `            ``# can attack Black King` `            ``if` `board[i][j] ``=``=` `'K'``:` `                ``# Check for Knight` `                ``if` `lookForn(board, ``'n'``, i, j):` `                    ``return` `2`   `                ``# Check for Pawn` `                ``if` `lookForp(board, ``'p'``, i, j):` `                    ``return` `2`   `                ``# Check for Rook` `                ``if` `lookForr(board, ``'r'``, i, j):` `                    ``return` `2`   `                ``# Check for Bishop` `                ``if` `lookForb(board, ``'b'``, i, j):` `                    ``return` `2`   `                ``# Check for Queen` `                ``if` `lookForq(board, ``'q'``, i, j):` `                    ``return` `2`   `                ``# Check for King` `                ``if` `lookFork(board, ``'k'``, i, j):` `                    ``return` `2` `    ``return` `1`   `def` `lookFork(board, c, i, j):` `    ``# Store all possible moves of the king` `    ``x ``=` `[ ``-``1``, ``-``1``, ``-``1``, ``0``, ``0``, ``1``, ``1``, ``1` `]` `    ``y ``=` `[ ``-``1``, ``0``, ``1``, ``-``1``, ``1``, ``-``1``, ``0``, ``1` `]`   `    ``for` `k ``in` `range``(``8``):` `        ``# incrementing index values` `        ``m ``=` `i ``+` `x[k]` `        ``n ``=` `j ``+` `y[k]`   `        ``# checking boundary conditions` `        ``# and character match` `        ``if` `inBounds(m, n) ``and` `board[m][n] ``=``=` `c:` `            ``return` `True` `    ``return` `False`   `# Function to check if Queen can attack the King` `def` `lookForq(board, c, i, j):` `  `  `    ``# Queen's moves are a combination` `    ``# of both the Bishop and the Rook` `    ``if` `lookForb(board, c, i, j) ``or` `lookForr(board, c, i, j):` `        ``return` `True` `    ``return` `False`   `# Function to check if bishop can attack the king` `def` `lookForb(board, c, i, j):` `    ``# Check the lower right diagonal` `    ``k ``=` `0` `    ``while` `inBounds(i ``+` `+``+``k, j ``+` `k):` `        ``if` `board[i ``+` `k][j ``+` `k] ``=``=` `c:` `            ``return` `True` `        ``if` `board[i ``+` `k][j ``+` `k] !``=` `'-'``:` `            ``break`   `    ``# Check the lower left diagonal` `    ``k ``=` `0` `    ``while` `inBounds(i ``+` `+``+``k, j ``-` `k):` `        ``if` `board[i ``+` `k][j ``-` `k] ``=``=` `c:` `            ``return` `True` `        ``if` `board[i ``+` `k][j ``-` `k] !``=` `'-'``:` `            ``break`   `    ``# Check the upper right diagonal` `    ``k ``=` `0` `    ``while` `inBounds(i ``-` `+``+``k, j ``+` `k):` `        ``if` `board[i ``-` `k][j ``+` `k] ``=``=` `c:` `            ``return` `True` `        ``if` `board[i ``-` `k][j ``+` `k] !``=` `'-'``:` `            ``break`   `    ``# Check the upper left diagonal` `    ``k ``=` `0` `    ``while` `inBounds(i ``-` `+``+``k, j ``-` `k):` `        ``if` `board[i ``-` `k][j ``-` `k] ``=``=` `c:` `            ``return` `True` `        ``if` `board[i ``-` `k][j ``-` `k] !``=` `'-'``:` `            ``break`   `    ``return` `False`   `# Check if` `def` `lookForr(board, c, i, j):` `    ``# Check downwards` `    ``k ``=` `0` `    ``while` `inBounds(i ``+` `+``+``k, j):` `        ``if` `board[i ``+` `k][j] ``=``=` `c:` `            ``return` `True` `        ``if` `board[i ``+` `k][j] !``=` `'-'``:` `            ``break`   `    ``# Check upwards` `    ``k ``=` `0` `    ``while` `inBounds(i ``+` `-``-``k, j):` `        ``if` `board[i ``+` `k][j] ``=``=` `c:` `            ``return` `True` `        ``if` `board[i ``+` `k][j] !``=` `'-'``:` `            ``break`   `    ``# Check right` `    ``k ``=` `0` `    ``while` `inBounds(i, j ``+` `+``+``k):` `        ``if` `board[i][j ``+` `k] ``=``=` `c:` `            ``return` `True` `        ``if` `board[i][j ``+` `k] !``=` `'-'``:` `            ``break`   `    ``# Check left` `    ``k ``=` `0` `    ``while` `inBounds(i, j ``+` `-``-``k):` `        ``if` `board[i][j ``+` `k] ``=``=` `c:` `            ``return` `True` `        ``if` `board[i][j ``+` `k] !``=` `'-'``:` `            ``break` `    ``return` `False`   `# Check if the knight can attack the king` `def` `lookForn(board, c, i, j):` `    ``# All possible moves of the knight` `    ``x ``=` `[ ``2``, ``2``, ``-``2``, ``-``2``, ``1``, ``1``, ``-``1``, ``-``1` `]` `    ``y ``=` `[ ``1``, ``-``1``, ``1``, ``-``1``, ``2``, ``-``2``, ``2``, ``-``2` `]`   `    ``for` `k ``in` `range``(``8``):` `        ``# Incrementing index values` `        ``m ``=` `i ``+` `x[k]` `        ``n ``=` `j ``+` `y[k]`   `        ``# Checking boundary conditions` `        ``# and character match` `        ``if` `inBounds(m, n) ``and` `board[m][n] ``=``=` `c:` `            ``return` `True` `    ``return` `False`   `# Function to check if pawn can attack the king` `def` `lookForp(board, c, i, j):` `    ``if` `ord``(c) >``=` `65` `and` `ord``(c) <``=` `90``:` `        ``# Check for white pawn` `        ``lookFor ``=` `'P'` `        ``if` `inBounds(i ``+` `1``, j ``-` `1``) ``and` `board[i ``+` `1``][j ``-` `1``] ``=``=` `lookFor:` `            ``return` `True`   `        ``if` `inBounds(i ``+` `1``, j ``+` `1``) ``and` `board[i ``+` `1``][j ``+` `1``] ``=``=` `lookFor:` `            ``return` `True` `    ``else``:` `        ``# Check for black pawn` `        ``lookFor ``=` `'p'` `        ``if` `inBounds(i ``-` `1``, j ``-` `1``) ``and` `board[i ``-` `1``][j ``-` `1``] ``=``=` `lookFor:` `            ``return` `True` `        ``if` `inBounds(i ``-` `1``, j ``+` `1``) ``and` `board[i ``-` `1``][j ``+` `1``] ``=``=` `lookFor:` `            ``return` `True` `    ``return` `False`   `# Check if the indices are within` `# the matrix or not` `def` `inBounds(i, j):` `    ``# Checking boundary conditions` `    ``return` `i >``=` `0` `and` `i < ``8` `and` `j >``=` `0` `and` `j < ``8`   `# Chessboard instance` `board ``=` `[ [ ``'-'``, ``'-'``, ``'-'``, ``'k'``, ``'-'``, ``'-'``, ``'-'``, ``'-'` `],` `  ``[ ``'p'``, ``'p'``, ``'p'``, ``'-'``, ``'p'``, ``'p'``, ``'p'``, ``'p'` `],` `  ``[ ``'-'``, ``'-'``, ``'-'``, ``'-'``, ``'-'``, ``'b'``, ``'-'``, ``'-'` `],` `  ``[ ``'-'``, ``'-'``, ``'-'``, ``'R'``, ``'-'``, ``'-'``, ``'-'``, ``'-'` `],` `  ``[ ``'-'``, ``'-'``, ``'-'``, ``'-'``, ``'-'``, ``'-'``, ``'-'``, ``'-'` `],` `  ``[ ``'-'``, ``'-'``, ``'-'``, ``'-'``, ``'-'``, ``'-'``, ``'-'``, ``'-'` `],` `  ``[ ``'P'``, ``'-'``, ``'P'``, ``'P'``, ``'P'``, ``'P'``, ``'P'``, ``'P'` `],` `  ``[ ``'K'``, ``'-'``, ``'-'``, ``'-'``, ``'-'``, ``'-'``, ``'-'``, ``'-'` `] ]`   `if` `checkBoard(board) ``=``=` `0``:` `  ``print``(``"No king in danger"``)` `elif` `checkBoard(board) ``=``=` `1``:` `  ``print``(``"White king in danger"``)` `else``:` `  ``print``(``"Black king in danger"``)` `  `  `  ``# This code is contributed by divyeshrabadiya07.`

## C#

 `using` `System;`   `class` `GFG{ `   `// Function to check if any of the two ` `// kings is unsafe or not ` `private` `static` `int` `checkBoard(``char``[,] board) ` `{ ` `    `  `    ``// Find the position of both the kings ` `    ``for``(``int` `i = 0; i < 8; i++)` `    ``{ ` `        ``for``(``int` `j = 0; j < 8; j++) ` `        ``{ ` `            `  `            ``// Check for all pieces which ` `            ``// can attack White King ` `            ``if` `(board[i, j] == ``'k'``)` `            ``{ `   `                ``// Check for Knight ` `                ``if` `(lookForn(board, ``'N'``, i, j)) ` `                    ``return` `1; `   `                ``// Check for Pawn ` `                ``if` `(lookForp(board, ``'P'``, i, j)) ` `                    ``return` `1; `   `                ``// Check for Rook ` `                ``if` `(lookForr(board, ``'R'``, i, j)) ` `                    ``return` `1; `   `                ``// Check for Bishop ` `                ``if` `(lookForb(board, ``'B'``, i, j)) ` `                    ``return` `1; `   `                ``// Check for Queen ` `                ``if` `(lookForq(board, ``'Q'``, i, j)) ` `                    ``return` `1; `   `                ``// Check for King ` `                ``if` `(lookFork(board, ``'K'``, i, j)) ` `                    ``return` `1; ` `            ``} `   `            ``// Check for all pieces which ` `            ``// can attack Black King ` `            ``if` `(board[i, j] == ``'K'``) ` `            ``{ `   `                ``// Check for Knight ` `                ``if` `(lookForn(board, ``'n'``, i, j)) ` `                    ``return` `2; `   `                ``// Check for Pawn ` `                ``if` `(lookForp(board, ``'p'``, i, j)) ` `                    ``return` `2; `   `                ``// Check for Rook ` `                ``if` `(lookForr(board, ``'r'``, i, j)) ` `                    ``return` `2; `   `                ``// Check for Bishop ` `                ``if` `(lookForb(board, ``'b'``, i, j)) ` `                    ``return` `2; `   `                ``// Check for Queen ` `                ``if` `(lookForq(board, ``'q'``, i, j)) ` `                    ``return` `2; `   `                ``// Check for King ` `                ``if` `(lookFork(board, ``'k'``, i, j)) ` `                    ``return` `2; ` `            ``} ` `        ``} ` `    ``} ` `    ``return` `0; ` `} `   `private` `static` `bool` `lookFork(``char``[,] board, ` `                             ``char` `c, ``int` `i,` `                             ``int` `j) ` `{ `   `    ``// Store all possible moves of the king ` `    ``int``[] x = { -1, -1, -1, 0, 0, 1, 1, 1 }; ` `    ``int``[] y = { -1, 0, 1, -1, 1, -1, 0, 1 }; `   `    ``for``(``int` `k = 0; k < 8; k++) ` `    ``{ ` `        `  `        ``// Incrementing index values ` `        ``int` `m = i + x[k]; ` `        ``int` `n = j + y[k]; `   `        ``// Checking boundary conditions ` `        ``// and character match ` `        ``if` `(inBounds(m, n) && board[m, n] == c) ` `            ``return` `true``; ` `    ``} ` `    ``return` `false``; ` `} `   `// Function to check if Queen can attack the King ` `private` `static` `bool` `lookForq(``char``[,] board, ` `                             ``char` `c, ``int` `i, ` `                             ``int` `j) ` `{ ` `    `  `    ``// Queen's moves are a combination ` `    ``// of both the Bishop and the Rook ` `    ``if` `(lookForb(board, c, i, j) ||` `        ``lookForr(board, c, i, j)) ` `        ``return` `true``; `   `    ``return` `false``; ` `} `   `// Function to check if bishop can attack the king ` `private` `static` `bool` `lookForb(``char``[,] board, ` `                             ``char` `c, ``int` `i, ` `                             ``int` `j) ` `{ `   `    ``// Check the lower right diagonal ` `    ``int` `k = 0; ` `    ``while` `(inBounds(i + ++k, j + k))` `    ``{ ` `        ``if` `(board[i + k, j + k] == c) ` `            ``return` `true``; ` `        ``if` `(board[i + k, j + k] != ``'-'``) ` `            ``break``; ` `    ``} `   `    ``// Check the lower left diagonal ` `    ``k = 0; ` `    ``while` `(inBounds(i + ++k, j - k)) ` `    ``{ ` `        ``if` `(board[i + k, j - k] == c) ` `            ``return` `true``; ` `        ``if` `(board[i + k, j - k] != ``'-'``) ` `            ``break``; ` `    ``} `   `    ``// Check the upper right diagonal ` `    ``k = 0; ` `    ``while` `(inBounds(i - ++k, j + k))` `    ``{ ` `        ``if` `(board[i - k, j + k] == c) ` `            ``return` `true``; ` `        ``if` `(board[i - k, j + k] != ``'-'``) ` `            ``break``; ` `    ``} `   `    ``// Check the upper left diagonal ` `    ``k = 0; ` `    ``while` `(inBounds(i - ++k, j - k))` `    ``{ ` `        ``if` `(board[i - k, j - k] == c) ` `            ``return` `true``; ` `        ``if` `(board[i - k, j - k] != ``'-'``) ` `            ``break``; ` `    ``} ` `    ``return` `false``; ` `} `   `// Check if ` `private` `static` `bool` `lookForr(``char``[,] board, ` `                             ``char` `c, ``int` `i,` `                             ``int` `j) ` `{ ` `    `  `    ``// Check downwards ` `    ``int` `k = 0; ` `    ``while` `(inBounds(i + ++k, j)) ` `    ``{ ` `        ``if` `(board[i + k, j] == c) ` `            ``return` `true``; ` `        ``if` `(board[i + k, j] != ``'-'``) ` `            ``break``; ` `    ``} `   `    ``// Check upwards ` `    ``k = 0; ` `    ``while` `(inBounds(i + --k, j))` `    ``{ ` `        ``if` `(board[i + k, j] == c) ` `            ``return` `true``; ` `        ``if` `(board[i + k, j] != ``'-'``) ` `            ``break``; ` `    ``} `   `    ``// Check right ` `    ``k = 0; ` `    ``while` `(inBounds(i, j + ++k)) ` `    ``{ ` `        ``if` `(board[i, j + k] == c) ` `            ``return` `true``; ` `        ``if` `(board[i, j + k] != ``'-'``) ` `            ``break``; ` `    ``} `   `    ``// Check left ` `    ``k = 0; ` `    ``while` `(inBounds(i, j + --k))` `    ``{ ` `        ``if` `(board[i, j + k] == c) ` `            ``return` `true``; ` `        ``if` `(board[i, j + k] != ``'-'``) ` `            ``break``; ` `    ``} ` `    ``return` `false``; ` `} `   `// Check if the knight can attack the king ` `private` `static` `bool` `lookForn(``char``[,] board, ` `                             ``char` `c, ``int` `i, ` `                             ``int` `j) ` `{ `   `    ``// All possible moves of the knight ` `    ``int``[] x = { 2, 2, -2, -2, 1, 1, -1, -1 }; ` `    ``int``[] y = { 1, -1, 1, -1, 2, -2, 2, -2 }; `   `    ``for``(``int` `k = 0; k < 8; k++)` `    ``{ ` `        `  `        ``// Incrementing index values ` `        ``int` `m = i + x[k]; ` `        ``int` `n = j + y[k]; `   `        ``// Checking boundary conditions ` `        ``// and character match ` `        ``if` `(inBounds(m, n) && board[m, n] == c) ` `            ``return` `true``; ` `    ``} ` `    ``return` `false``; ` `} `   `// Function to check if pawn can attack the king ` `private` `static` `bool` `lookForp(``char``[,] board, ` `                             ``char` `c, ``int` `i, ` `                             ``int` `j) ` `{ ` `    ``char` `lookFor; ` `    ``if` `(``char``.IsUpper(c))` `    ``{ ` `        `  `        ``// Check for white pawn ` `        ``lookFor = ``'P'``; ` `        ``if` `(inBounds(i + 1, j - 1) && ` `               ``board[i + 1, j - 1] == lookFor) ` `            ``return` `true``; `   `        ``if` `(inBounds(i + 1, j + 1) &&` `               ``board[i + 1, j + 1] == lookFor) ` `            ``return` `true``; ` `    ``} ` `    ``else` `    ``{ `   `        ``// Check for black pawn ` `        ``lookFor = ``'p'``; ` `        ``if` `(inBounds(i - 1, j - 1) &&` `               ``board[i - 1, j - 1] == lookFor) ` `            ``return` `true``; ` `        ``if` `(inBounds(i - 1, j + 1) && ` `               ``board[i - 1, j + 1] == lookFor) ` `            ``return` `true``; ` `    ``} ` `    ``return` `false``; ` `} `   `// Check if the indices are within ` `// the matrix or not ` `private` `static` `bool` `inBounds(``int` `i, ``int` `j) ` `{ `   `    ``// Checking boundary conditions ` `    ``return` `i >= 0 && i < 8 && j >= 0 && j < 8; ` `} `   `// Driver Code ` `public` `static` `void` `Main(String[] args) ` `{ `   `    ``// Chessboard instance ` `    ``char``[,] board ` `        ``= { { ``'-'``, ``'-'``, ``'-'``, ``'k'``, ``'-'``, ``'-'``, ``'-'``, ``'-'` `}, ` `            ``{ ``'p'``, ``'p'``, ``'p'``, ``'-'``, ``'p'``, ``'p'``, ``'p'``, ``'p'` `}, ` `            ``{ ``'-'``, ``'-'``, ``'-'``, ``'-'``, ``'-'``, ``'b'``, ``'-'``, ``'-'` `}, ` `            ``{ ``'-'``, ``'-'``, ``'-'``, ``'R'``, ``'-'``, ``'-'``, ``'-'``, ``'-'` `}, ` `            ``{ ``'-'``, ``'-'``, ``'-'``, ``'-'``, ``'-'``, ``'-'``, ``'-'``, ``'-'` `}, ` `            ``{ ``'-'``, ``'-'``, ``'-'``, ``'-'``, ``'-'``, ``'-'``, ``'-'``, ``'-'` `}, ` `            ``{ ``'P'``, ``'-'``, ``'P'``, ``'P'``, ``'P'``, ``'P'``, ``'P'``, ``'P'` `}, ` `            ``{ ``'K'``, ``'-'``, ``'-'``, ``'-'``, ``'-'``, ``'-'``, ``'-'``, ``'-'` `} }; `   `    ``if` `(checkBoard(board) == 0) ` `        ``Console.WriteLine(``"No king in danger"``); `   `    ``else` `if` `(checkBoard(board) == 1) ` `        ``Console.WriteLine(``"White king in danger"``); `   `    ``else` `        ``Console.WriteLine(``"Black king in danger"``); ` `} ` `} `   `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output:

`White king in danger`

Time Complexity: O(N3
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Recommended Articles
Page :