Check if any King is unsafe on the Chessboard or not - GeeksforGeeks

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:  
Check for the position of both white and black kings.For each king, check Rook, bishops, knight, king, Queen, Pawn of the opposite color, whether they are attacking the king or not.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.If none of the attack conditions are satisfied for any of the two kings, then there is no danger to both the king.Otherwise, print the answer for the king whose unsafe condition is satisfied.
Check for the position of both white and black kings.
For each king, check Rook, bishops, knight, king, Queen, Pawn of the opposite color, whether they are attacking the king or not.
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.
If none of the attack conditions are satisfied for any of the two kings, then there is no danger to both the king.
Otherwise, print the answer for the king whose unsafe condition is satisfied.
Below is the implementation of this approach.
C++
Java
Python3
C#
Javascript
// C++ program to implement the// above approach#include <bits/stdc++.h>using namespace std; // Check if the indices// are within the matrix// or notbool inBounds(int i,              int j){  // Checking boundary  // conditions  return i >= 0 && i < 8 &&         j >= 0 && j < 8;} bool lookFork(char board[][8],              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 kingbool lookForb(char board[][8],              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 ifbool lookForr(char board[][8],              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 Kingbool lookForq(char board[][8],              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 kingbool lookForn(char board[][8],              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 kingbool lookForp(char board[][8],              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 notint checkBoard(char board[][8]){  // 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 Codeint main(){  // Chessboard instance  char board[][8] = {{'-', '-', '-', '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
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 program to implement the above approach # Function to check if any of the two# kings is unsafe or notdef 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 Kingdef 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 kingdef 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 ifdef 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 kingdef 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 kingdef 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 notdef inBounds(i, j):    # Checking boundary conditions    return i >= 0 and i < 8 and j >= 0 and j < 8 # Chessboard instanceboard = [ [ '-', '-', '-', '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.
using System; class GFG{ // Function to check if any of the two// kings is unsafe or notprivate 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 Kingprivate 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 kingprivate 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 ifprivate 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 kingprivate 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 kingprivate 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 notprivate static bool inBounds(int i, int j){     // Checking boundary conditions    return i >= 0 && i < 8 && j >= 0 && j < 8;} // Driver Codepublic 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
<script>    // Javascript program to implement the above approach         // Function to check if any of the two    // kings is unsafe or not    function checkBoard(board)    {          // Find the position of both the kings        for (let i = 0; i < 8; i++) {            for (let 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;    }      function lookFork(board, c, i, j)    {          // Store all possible moves of the king        let x = [ -1, -1, -1, 0, 0, 1, 1, 1 ];        let y = [ -1, 0, 1, -1, 1, -1, 0, 1 ];          for (let k = 0; k < 8; k++) {              // incrementing index values            let m = i + x[k];            let 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    function lookForq(board, c, i, 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    function lookForb(board, c, i, j)    {          // Check the lower right diagonal        let 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    function lookForr(board, c, i, j)    {          // Check downwards        let 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    function lookForn(board, c, i, j)    {          // All possible moves of the knight        let x = [ 2, 2, -2, -2, 1, 1, -1, -1 ];        let y = [ 1, -1, 1, -1, 2, -2, 2, -2 ];          for (let k = 0; k < 8; k++) {              // Incrementing index values            let m = i + x[k];            let 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    function lookForp(board, c, i, j)    {          let lookFor;        if (c.charCodeAt() >= 65 && c.charCodeAt() <= 90) {              // 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    function inBounds(i, j)    {          // Checking boundary conditions        return i >= 0 && i < 8 && j >= 0 && j < 8;    }         // Chessboard instance    let board      = [ [ '-', '-', '-', 'k', '-', '-', '-', '-' ],      [ 'p', 'p', 'p', '-', 'p', 'p', 'p', 'p' ],      [ '-', '-', '-', '-', '-', 'b', '-', '-' ],      [ '-', '-', '-', 'R', '-', '-', '-', '-' ],      [ '-', '-', '-', '-', '-', '-', '-', '-' ],      [ '-', '-', '-', '-', '-', '-', '-', '-' ],      [ 'P', '-', 'P', 'P', 'P', 'P', 'P', 'P' ],      [ 'K', '-', '-', '-', '-', '-', '-', '-' ] ];     if (checkBoard(board) == 0)      document.write("No king in danger");     else if (checkBoard(board) == 1)      document.write("White king in danger");     else      document.write("Black king in danger");         // This code is contributed by divyesh072019.</script>
  
White king in danger
 
Time Complexity: O(N3) Auxiliary Space: O(1)
29AjayKumar
ukasp
divyesh072019
divyeshrabadiya07
BFS
chessboard-problems
Backtracking
Graph
Matrix
Recursion
Recursion
Matrix
Graph
Backtracking
BFS
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Tug of War
Find if there is a path of more than k length from a source
Difference between Backtracking and Branch-N-Bound technique
Find shortest safe route in a path with landmines
Print all possible strings that can be made by placing spaces
Breadth First Search or BFS for a Graph
Dijkstra's shortest path algorithm | Greedy Algo-7
Depth First Search or DFS for a Graph
Kruskal’s Minimum Spanning Tree Algorithm | Greedy Algo-2
Prim’s Minimum Spanning Tree (MST) | Greedy Algo-5