Check if any King is unsafe on the Chessboard or not
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.
Below is the implementation of this approach.
C++
// 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 |
chevron_right
filter_none
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"); }} |
chevron_right
filter_none
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 |
chevron_right
filter_none
Output:
White king in danger
Time Complexity: O(N3)
Auxiliary Space: O(1)
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.
