Open In App

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy

Find all the queens attacking the king in a chessboard

Given a 2D array queens[][] consisting of coordinates of N queens in an 8 * 8 chessboard and an array king[] denoting the coordinates of the king, the task is to find the queens that are attacking the king

Examples:



Input: queens[][] = {{0, 1}, {1, 0}, {4, 0}, {0, 4}, {3, 3}, {2, 4}}, king[] = {2, 3} 
Output: {{0, 1}, {2, 4}, {3, 3}}

Explanation:The queens at coordinates {0, 1} and {3, 3} are diagonally attacking the king and the queen at {2, 4} is vertically below the king.



Input: queens[][]] = {{4, 1}, {1, 0}, {4, 0}}, king[] = {0, 0} 
Output : {{1, 0}} 

 

Approach Follow the steps below to solve the problem:

Below is the implementation of the above approach:




// C++ Program to implement
// the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the queen
// closest to king in an
// attacking position
int dis(vector<int> ans,
        vector<int> attacker)
{
    return abs(ans[0] - attacker[0])
           + abs(ans[1] - attacker[1]);
}
 
// Function to find all the queens
// attacking the king in the chessboard
vector<vector<int> > findQueens(
    vector<vector<int> >& queens,
    vector<int>& king)
{
    vector<vector<int> > sol;
    vector<vector<int> > attackers(8);
 
    // Iterating over the coordinates
    // of the queens
    for (int i = 0; i < queens.size(); i++) {
 
        // If king is horizontally on
        // the right of current queen
        if (king[0] == queens[i][0]
            && king[1] > queens[i][1]) {
 
            // If no attacker is present
            // in that direction
            if ((attackers[3].size() == 0)
 
                // Or if the current queen is
                // closest in that direction
                || (dis(attackers[3], king)
                    > dis(queens[i], king)))
 
                // Set current queen as
                // the attacker
                attackers[3] = queens[i];
        }
 
        // If king is horizontally on
        // the left of current queen
        if (king[0] == queens[i][0]
            && king[1] < queens[i][1]) {
 
            // If no attacker is present
            // in that direction
            if ((attackers[4].size() == 0)
 
                // Or if the current queen is
                // closest in that direction
                || (dis(attackers[4], king)
                    > dis(queens[i], king)))
 
                // Set current queen as
                // the attacker
                attackers[4] = queens[i];
        }
 
        // If the king is attacked by a
        // queen from the left by a queen
        // diagonally above
        if (king[0] - queens[i][0]
                == king[1] - queens[i][1]
            && king[0] > queens[i][0]) {
 
            // If no attacker is present in
            // that direction
            if ((attackers[0].size() == 0)
 
                // Or the current queen is
                // the closest attacker in
                // that direction
                || (dis(attackers[0], king)
                    > dis(queens[i], king)))
 
                // Set current queen as
                // the attacker
                attackers[0] = queens[i];
        }
 
        // If the king is attacked by a
        // queen from the left by a queen
        // diagonally below
        if (king[0] - queens[i][0]
                == king[1] - queens[i][1]
            && king[0] < queens[i][0]) {
 
            // If no attacker is present in
            // that direction
            if ((attackers[7].size() == 0)
 
                // Or the current queen is
                // the closest attacker in
                // that direction
                || (dis(attackers[7], king)
                    > dis(queens[i], king)))
 
                // Set current queen as
                // the attacker
                attackers[7] = queens[i];
        }
 
        // If the king is attacked by a
        // queen from the right by a queen
        // diagonally above
        if (king[1] - queens[i][1] == 0
            && king[0] > queens[i][0]) {
 
            // If no attacker is present in
            // that direction
            if ((attackers[1].size() == 0)
 
                // Or the current queen is
                // the closest attacker in
                // that direction
                || (dis(attackers[1], king)
                    > dis(queens[i], king)))
 
                // Set current queen as
                // the attacker
                attackers[1] = queens[i];
        }
 
        // If the king is attacked by a
        // queen from the right by a queen
        // diagonally below
        if (king[1] - queens[i][1] == 0
            && king[0] < queens[i][0]) {
 
            // If no attacker is present in
            // that direction
            if ((attackers[6].size() == 0)
 
                // Or the current queen is
                // the closest attacker in
                // that direction
                || (dis(attackers[6], king)
                    > dis(queens[i], king)))
 
                // Set current queen as
                // the attacker
                attackers[6] = queens[i];
        }
 
        // If a king is vertically below
        // the current queen
        if (king[0] - queens[i][0]
                == -(king[1] - queens[i][1])
            && king[0] > queens[i][0]) {
 
            // If no attacker is present in
            // that direction
            if ((attackers[2].size() == 0)
 
                // Or the current queen is
                // the closest attacker in
                // that direction
                || (dis(attackers[2], king)
                    > dis(queens[i], king)))
 
                // Set current queen as
                // the attacker
                attackers[2] = queens[i];
        }
 
        // If a king is vertically above
        // the current queen
        if (king[0] - queens[i][0]
                == -(king[1] - queens[i][1])
            && king[0] < queens[i][0]) {
 
            // If no attacker is present in
            // that direction
            if ((attackers[5].size() == 0)
 
                // Or the current queen is
                // the closest attacker in
                // that direction
                || (dis(attackers[5], king)
                    > dis(queens[i], king)))
 
                // Set current queen as
                // the attacker
                attackers[5] = queens[i];
        }
    }
 
    for (int i = 0; i < 8; i++)
        if (attackers[i].size())
            sol.push_back(attackers[i]);
 
    // Return the coordinates
    return sol;
}
 
// Print all the coordinates of the
// queens attacking the king
void print(vector<vector<int> > ans)
{
    for (int i = 0; i < ans.size();
         i++) {
 
        for (int j = 0; j < 2; j++)
            cout << ans[i][j] << " ";
 
        cout << "\n";
    }
}
 
// Driver Code
int main()
{
    vector<int> king = { 2, 3 };
 
    vector<vector<int> > queens
        = { { 0, 1 }, { 1, 0 },
            { 4, 0 }, { 0, 4 },
            { 3, 3 }, { 2, 4 } };
 
    vector<vector<int> > ans
        = findQueens(queens, king);
 
    print(ans);
}
 





                        























                                    



                                    




                                    




                                    


                                



















// Java program to implement


// the above approach



import java.io.*;




import java.util.*;




import java.util.stream.Collectors;



 



class GFG{



 


// Method to find the queen closest


// to king in an attacking position



private static int dis(int[] ans, int[] attacker)



{



    return Math.abs(ans[0] - attacker[0]) + 




           Math.abs(ans[1] - attacker[1]);



}


 


// Method to find all the queens


// attacking the king in the chessboard



private static List<List<Integer>> findQueens(




    int[][] queens, int[] king)



{



    List<List<Integer>> sol = new ArrayList<List<Integer>>();




    int[][] attackers = new int[8][2];



 



    for(int i = 0; i < 8; i++) 




    {




        Arrays.fill(attackers[i], -1);




    }



 



    for(int i = 0; i < queens.length; i++)




    {




         



        // If king is horizontally on




        // the right of current queen




        if (king[0] == queens[i][0] &&




            king[1] > queens[i][1]) 




        {




             



            // If no attacker is present




            // in that direction




            if ((attackers[3][0] == -1) || 



 



                // Or if the current queen is




                // closest in that direction




                (dis(attackers[3], king) > 




                    dis(queens[i], king)))



 



                // Set current queen as




                // the attacker




                attackers[3] = queens[i];




        }



 



        // If king is horizontally on




        // the left of current queen




        if (king[0] == queens[i][0] && 




            king[1] < queens[i][1]) 




        {




             



            // If no attacker is present




            // in that direction




            if ((attackers[4][0] == -1) || 



 



                // Or if the current queen is




                // closest in that direction




                (dis(attackers[4], king) > 




                    dis(queens[i], king)))



 



                // Set current queen as




                // the attacker




                attackers[4] = queens[i];




        }



 



        // If the king is attacked by a




        // queen from the left by a queen




        // diagonally above




        if (king[0] - queens[i][0] == 




            king[1] - queens[i][1] &&




            king[0] > queens[i][0])




        {




             



            // If no attacker is present in




            // that direction




            if ((attackers[0][0] == -1) || 



 



                // Or the current queen is




                // the closest attacker in




                // that direction




                (dis(attackers[0], king) > 




                    dis(queens[i], king)))



 



                // Set current queen as




                // the attacker




                attackers[0] = queens[i];




        }



 



        // If the king is attacked by a




        // queen from the left by a queen




        // diagonally below




        if (king[0] - queens[i][0] == 




            king[1] - queens[i][1] && 




            king[0] < queens[i][0])




        {




             



            // If no attacker is present in




            // that direction




            if ((attackers[7][0] == -1) || 



 



                // Or the current queen is




                // the closest attacker in




                // that direction




               (dis(attackers[7], king) > 




                   dis(queens[i], king)))



 



                // Set current queen as




                // the attacker




                attackers[7] = queens[i];




        }



 



        // If the king is attacked by a




        // queen from the right by a queen




        // diagonally above




        if (king[1] - queens[i][1] == 0 && 




            king[0] > queens[i][0])




        {




             



            // If no attacker is present in




            // that direction




            if ((attackers[1][0] == -1) || 



 



                // Or the current queen is




                // the closest attacker in




                // that direction




                (dis(attackers[1], king) > 




                    dis(queens[i], king)))



 



                // Set current queen as




                // the attacker




                attackers[1] = queens[i];




        }



 



        // If the king is attacked by a




        // queen from the right by a queen




        // diagonally below




        if (king[1] - queens[i][1] == 0 && 




            king[0] < queens[i][0]) 




        {




             



            // If no attacker is present in




            // that direction




            if ((attackers[6][0] == -1) || 



 



                // Or the current queen is




                // the closest attacker in




                // that direction




                (dis(attackers[6], king) > 




                    dis(queens[i], king)))



 



                // Set current queen as




                // the attacker




                attackers[6] = queens[i];




        }



 



        // If a king is vertically below




        // the current queen




        if (king[0] - queens[i][0] == 




          -(king[1] - queens[i][1]) &&




            king[0] > queens[i][0])




        {




             



            // If no attacker is present in




            // that direction




            if ((attackers[2][0] == -1) || 



 



                // Or the current queen is




                // the closest attacker in




                // that direction




                (dis(attackers[2], king) > 




                    dis(queens[i], king)))



 



                // Set current queen as




                // the attacker




                attackers[2] = queens[i];




        }



 



        // If a king is vertically above




        // the current queen




        if (king[0] - queens[i][0] == 




          -(king[1] - queens[i][1]) && 




            king[0] < queens[i][0])




        {




             



            // If no attacker is present in




            // that direction




            if ((attackers[5][0] == -1) || 



 



                // Or the current queen is




                // the closest attacker in




                // that direction




                (dis(attackers[5], king) > 




                    dis(queens[i], king)))



 



                // Set current queen as




                // the attacker




                attackers[5] = queens[i];




        }




    }



 



    for(int i = 0; i < 8; i++)




        if (attackers[i][0] != -1)




            sol.add(




                Arrays.stream(




                    attackers[i]).boxed().collect(




                        Collectors.toList()));



 



    // Return the coordinates




    return sol;



}


 


// Print all the coordinates of the


// queens attacking the king



private static void print(List<List<Integer>> ans)



{



    for(int i = 0; i < ans.size(); i++)




    {




        for(int j = 0; j < 2; j++)




            System.out.print(ans.get(i).get(j) + " ");



 



        System.out.println();




    }



}


 


// Driver Code



public static void main(String[] args)



{



    int[] king = { 2, 3 };



 



    int[][] queens = { { 0, 1 }, { 1, 0 },




                       { 4, 0 }, { 0, 4 },




                       { 3, 3 }, { 2, 4 } };



 



    List<List<Integer>> ans = findQueens(queens, king);



 



    print(ans);



}


}


 


// This code is contributed by jithin


















                        






                        























                                    



                                    




                                    




                                    


                                



















# Python3 program to implement


# the above approach


 


# Function to find the queen


# closest to king in an


# attacking position



def dis(ans, attacker):



 



    return (abs(ans[0] - attacker[0]) +




            abs(ans[1] - attacker[1]))



 


# Function to find all the 


# queens attacking the king 


# in the chessboard



def findQueens(queens, king):



 



    sol = []




    attackers = [[0 for x in range(8)] 




                    for y in range(8)]



 



    # Iterating over the coordinates




    # of the queens




    for i in range(len(queens)):



 



        # If king is horizontally on




        # the right of current queen




        if (king[0] == queens[i][0] and




            king[1] > queens[i][1]):



 



            # If no attacker is present




            # in that direction




            if ((len(attackers[3]) == 0) 




                 



                # Or if the current queen is




                # closest in that direction




                or ((dis(attackers[3], king) > 




                     dis(queens[i], king)))):                



 



                # Set current queen as




                # the attacker




                attackers[3] = queens[i];



 



        # If king is horizontally on




        # the left of current queen




        if (king[0] == queens[i][0] and




            king[1] < queens[i][1]):



 



            # If no attacker is present




            # in that direction




            if ((len(attackers[4]) == 0)



 



                # Or if the current queen is




                # closest in that direction




                or (dis(attackers[4], king) > 




                    dis(queens[i], king))):



 



                # Set current queen as




                # the attacker




                attackers[4] = queens[i];



 



        # If the king is attacked by a




        # queen from the left by a queen




        # diagonally above




        if (king[0] - queens[i][0] ==




            king[1] - queens[i][1] and




            king[0] > queens[i][0]):



 



            # If no attacker is present in




            # that direction




            if ((len(attackers[0]) == 0)



 



                # Or the current queen is




                # the closest attacker in




                # that direction




                or (dis(attackers[0], king) > 




                    dis(queens[i], king))):



 



                # Set current queen as




                # the attacker




                attackers[0] = queens[i]



 



        # If the king is attacked by a




        # queen from the left by a queen




        # diagonally below




        if (king[0] - queens[i][0] ==




            king[1] - queens[i][1] and




            king[0] < queens[i][0]):



 



            # If no attacker is present in




            # that direction




            if ((len(attackers[7]) == 0)



 



                # Or the current queen is




                # the closest attacker in




                # that direction




                or (dis(attackers[7], king) > 




                    dis(queens[i], king))):



 



                # Set current queen as




                # the attacker




                attackers[7] = queens[i]



 



        # If the king is attacked by a




        # queen from the right by a queen




        # diagonally above




        if (king[1] - queens[i][1] == 0 and




            king[0] > queens[i][0]):



 



            # If no attacker is present in




            # that direction




            if ((len(attackers[1]) == 0)



 



                # Or the current queen is




                # the closest attacker in




                # that direction




                or (dis(attackers[1], king) > 




                    dis(queens[i], king))):



 



                # Set current queen as




                # the attacker




                attackers[1] = queens[i]



 



        # If the king is attacked by a




        # queen from the right by a queen




        # diagonally below




        if (king[1] - queens[i][1] == 0 and




            king[0] < queens[i][0]):



 



            # If no attacker is present in




            # that direction




            if ((len(attackers[6]) == 0)



 



                # Or the current queen is




                # the closest attacker in




                # that direction




                or (dis(attackers[6], king) > 




                    dis(queens[i], king))):



 



                # Set current queen as




                # the attacker




                attackers[6] = queens[i];



 



        # If a king is vertically below




        # the current queen




        if (king[0] - queens[i][0] ==




            -(king[1] - queens[i][1]) and




            king[0] > queens[i][0]):



 



            # If no attacker is present in




            # that direction




            if ((len(attackers[2]) == 0)



 



                # Or the current queen is




                # the closest attacker in




                # that direction




                or (dis(attackers[2], king) > 




                    dis(queens[i], king))):



 



                # Set current queen as




                # the attacker




                attackers[2] = queens[i]



 



        # If a king is vertically above




        # the current queen




        if (king[0] - queens[i][0] ==




          -(king[1] - queens[i][1]) and




            king[0] < queens[i][0]):



 



            # If no attacker is present in




            # that direction




            if ((len(attackers[5]) == 0)



 



                # Or the current queen is




                # the closest attacker in




                # that direction




                or (dis(attackers[5], king) > 




                    dis(queens[i], king))):



 



                # Set current queen as




                # the attacker




                attackers[5] = queens[i]




                     



    for i in range(8):




        f = 1




        for x in attackers[i]:




          if x != 0:




            f = 0




            break




        if f == 0:




          sol.append(attackers[i])



 



    # Return the coordinates




    return sol



 


# Print all the coordinates of the


# queens attacking the king



def print_board(ans):



 



    for i in range(len(ans)):




        for j in range(2):




            print(ans[i][j], 




                  end = " ")




             



        print()



 


# Driver Code



if __name__ == "__main__":



 



    king = [2, 3]




    queens = [[0, 1], [1, 0],




              [4, 0], [0, 4],




              [3, 3], [2, 4]]




    ans = findQueens(queens, king);




    print_board(ans);



 


# This code is contributed by Chitranayal


















                        






                        























                                    



                                    




                                    




                                    


                                



















// C# Program to implement


// the above approach



using System;




using System.Collections.Generic;




using System.Linq;



 



class GFG {




   


// Method to find the queen closest


// to king in an attacking position



    private static int dis(int[] ans, int[] attacker)




    {




        return Math.Abs(ans[0] - attacker[0])




            + Math.Abs(ans[1] - attacker[1]);




    }



// Method to find all the queens


// attacking the king in the chessboard



    private static List<List<int> >




    findQueens(int[][] queens, int[] king)




    {




        List<List<int> > sol = new List<List<int> >();




        int[][] attackers = new int[8][];




        for (int i = 0; i < 8; i++) {




            attackers[i] = new int[] { -1, -1 };




        }



 



        for (int i = 0; i < queens.Length; i++) {




           



           // If king is horizontally on




        // the right of current queen




            if (king[0] == queens[i][0]




                && king[1] > queens[i][1]) {




                    // If no attacker is present




            // in that direction




                if ((attackers[3][0] == -1)




                    || (dis(attackers[3], king)




                        > dis(queens[i], king)))




                    attackers[3] = queens[i];




            }




   // If king is horizontally on




        // the left of current queen




            if (king[0] == queens[i][0]




                && king[1] < queens[i][1]) {




                  



            // If no attacker is present




            // in that direction




                if ((attackers[4][0] == -1)




                    || (dis(attackers[4], king)




                        > dis(queens[i], king)))




                    attackers[4] = queens[i];




            }



 



            if (king[0] - queens[i][0]




                    == king[1] - queens[i][1]




                && king[0] > queens[i][0]) {




                if ((attackers[0][0] == -1)




                    || (dis(attackers[0], king)




                        > dis(queens[i], king)))




                    attackers[0] = queens[i];




            }



 



            if (king[0] - queens[i][0]




                    == king[1] - queens[i][1]




                && king[0] < queens[i][0]) {




                if ((attackers[7][0] == -1)




                    || (dis(attackers[7], king)




                        > dis(queens[i], king)))




                    attackers[7] = queens[i];




            }



 



            if (king[1] - queens[i][1] == 0




                && king[0] > queens[i][0]) {




                if ((attackers[1][0] == -1)




                    || (dis(attackers[1], king)




                        > dis(queens[i], king)))




                    attackers[1] = queens[i];




            }



 



            if (king[1] - queens[i][1] == 0




                && king[0] < queens[i][0]) {




                if ((attackers[6][0] == -1)




                    || (dis(attackers[6], king)




                        > dis(queens[i], king)))




                    attackers[6] = queens[i];




            }



 



            if (king[0] - queens[i][0]




                    == -(king[1] - queens[i][1])




                && king[0] > queens[i][0]) {




                if ((attackers[2][0] == -1)




                    || (dis(attackers[2], king)




                        > dis(queens[i], king)))




                    attackers[2] = queens[i];




            }



 



            if (king[0] - queens[i][0]




                    == -(king[1] - queens[i][1])




                && king[0] < queens[i][0]) {




                if ((attackers[5][0] == -1)




                    || (dis(attackers[5], king)




                        > dis(queens[i], king)))




                    attackers[5] = queens[i];




            }




        }




      // Print all the coordinates of the



// queens attacking the king


 



        for (int i = 0; i < 8; i++) {




            if (attackers[i][0] != -1) {




                List<int> temp = new List<int>();




                temp.Add(attackers[i][0]);




                temp.Add(attackers[i][1]);




                sol.Add(temp);




            }




        }



//Return the coordinates



        return sol;




    }



//Driver code



    public static void Main()




    {




        int[][] queens = new int[6][];




        queens[0] = new int[] { 0, 1 };




        queens[1] = new int[] { 1, 0 };




        queens[2] = new int[] { 4, 0 };




        queens[3] = new int[] { 0, 4 };




        queens[4] = new int[] { 3, 3 };




        queens[5] = new int[] { 2, 4 };



 



        int[] king = new int[] { 2, 3 };



 



        List<List<int> > res = findQueens(queens, king);



 



        foreach(List<int> l in res)




        {




            Console.WriteLine("(" + l[0] + ", " + l[1]




                              + ")");




        }




    }



}


















                        






                        























                                    



                                    




                                    




                                    


                                



















// JavaScript program to implement


// the above approach


 


// Method to find the queen closest


// to king in an attacking position



function dis(ans, attacker) {




    return Math.abs(ans[0] - attacker[0]) + Math.abs(ans[1] - attacker[1]);



}


 


// Method to find all the queens


// attacking the king in the chessboard



function findQueens(queens, king) {




    let sol = [];




    let attackers = Array.from({




        length: 8




    }, () => Array(8).fill(0));




    for (let i = 0; i < queens.length; i++) {




        // If king is horizontally on




        // the right of current queen




        if (king[0] === queens[i][0] && king[1] > queens[i][1]) {




            // If no attacker is present




            // in that direction




            // Or if the current queen is




            // closest in that direction




            if (attackers[3].length === 0 || dis(attackers[3], king) > dis(queens[i], king)) {



 



                // Set current queen as




                // the attacker




                attackers[3] = queens[i];




            }




        }



 



        // If king is horizontally on




        // the left of current queen




        if (king[0] === queens[i][0] && king[1] < queens[i][1]) {




            // If no attacker is present




            // in that direction




            // Or if the current queen is




            // closest in that direction




            if (attackers[4].length === 0 || dis(attackers[4], king) > dis(queens[i], king)) {



 



                // Set current queen as




                // the attacker




                attackers[4] = queens[i];




            }




        }



 


 



        // If the king is attacked by a




        // queen from the left by a queen




        // diagonally above




        if (king[0] - queens[i][0] === king[1] - queens[i][1] && king[0] > queens[i][0]) {



 



            // If no attacker is present in




            // that direction




            // Or the current queen is




            // the closest attacker in




            // that direction




            if (attackers[0].length === 0 || dis(attackers[0], king) > dis(queens[i], king)) {



 



                // Set current queen as




                // the attacker




                attackers[0] = queens[i];




            }




        }



 



        // If the king is attacked by a




        // queen from the left by a queen




        // diagonally below




        if (king[0] - queens[i][0] === king[1] - queens[i][1] && king[0] < queens[i][0]) {



 



            // If no attacker is present in




            // that direction




            // Or the current queen is




            // the closest attacker in




            // that direction




            if (attackers[7].length === 0 || dis(attackers[7], king) > dis(queens[i], king)) {



 



                // Set current queen as




                // the attacker




                attackers[7] = queens[i];




            }




        }



 



        // If the king is attacked by a




        // queen from the right by a queen




        // diagonally above




        if (king[1] - queens[i][1] === 0 && king[0] > queens[i][0]) {




            // If no attacker is present in




            // that direction




            // Or the current queen is




            // the closest attacker in




            // that direction




            if (attackers[1].length === 0 || dis(attackers[1], king) > dis(queens[i], king)) {




                // Set current queen as




                // the attacker




                attackers[1] = queens[i];




            }




        }



 



        // If the king is attacked by a




        // queen from the right by a queen




        // diagonally below




        if (king[1] - queens[i][1] === 0 && king[0] < queens[i][0]) {




            // If no attacker is present in




            // that direction




            // Or the current queen is




            // the closest attacker in




            // that direction




            if (attackers[6].length === 0 || dis(attackers[6], king) > dis(queens[i], king)) {




                // Set current queen as




                // the attacker




                attackers[6] = queens[i];




            }




        }



 



        // If a king is vertically below




        // the current queen




        if (king[0] - queens[i][0] === -(king[1] - queens[i][1]) && king[0] > queens[i][0]) {



 



            // If no attacker is present in




            // that direction




            // Or the current queen is




            // the closest attacker in




            // that direction




            if (attackers[2].length === 0 || dis(attackers[2], king) > dis(queens[i], king)) {




                // Set current queen as




                // the attacker




                attackers[2] = queens[i];




            }




        }




        // If a king is vertically above




        // the current queen




        if (king[0] - queens[i][0] === -(king[1] - queens[i][1]) && king[0] < queens[i][0]) {




            // If no attacker is present in




            // that direction




            // Or the current queen is




            // the closest attacker in




            // that direction




            if (attackers[5].length === 0 || dis(attackers[5], king) > dis(queens[i], king)) {




                // Set current queen as




                // the attacker




                attackers[5] = queens[i];




            }




        }




    }



 


 


 



    for (let i = 0; i < 8; i++) {




        let f = 1;




        for (let x of attackers[i]) {




            if (x !== 0) {




                f = 0;




                break;




            }




        }




        if (f === 0) {




            sol.push(attackers[i]);




        }




    }



 



    // Return the coordinates




    return sol;



}


 


// Driver Code


let king = [2, 3];


let queens = [



    [0, 1],




    [1, 0],




    [4, 0],




    [0, 4],




    [3, 3],




    [2, 4]



];


let ans = findQueens(queens, king);


print_board(ans);


 



function print_board(ans) {




    for (let i = 0; i < ans.length; i++) {




        console.log(ans[i][0] + " " + ans[i][1]);




    }



}


 


// Contributed by sdeadityasharma


















                        






                        








Output: 

0 1 
2 4 
3 3


 


Time Complexity: O(N), where N is the number of queens 
Auxiliary Space: O(N)

	

        Article Tags : 
        

            Arrays
DSA
Matrix
Searching
Technical Scripter        


		
	

	


      

      

          
Recommended Articles

      

      

          
          
1. Find position of non-attacking Rooks in lexicographic order that can be placed on N*N chessboard

          
2. Maximum non-attacking Knights that can be placed on an N*M Chessboard

          
3. Maximum non-attacking Rooks that can be placed on an N*N Chessboard

          
4. CSES Solutions - Chessboard and Queens

          
5. Check if a king can move a valid move or not when N nights are there in a modified chessboard

          
6. Total position where king can reach on a chessboard in exactly M moves

          
7. Total position where king can reach on a chessboard in exactly M moves | Set 2

          
8. Check if any King is unsafe on the Chessboard or not

          
9. Count positions in a chessboard that can be visited by the Queen which are not visited by the King

          
10. Minimum queens required to cover all the squares of a chess board

          
11. Number of ways to place two queens on a N*N chess-board

          
12. 4 Queens Problem

          
13. Minimum number of moves required to reach the destination by the king in a chess board

          
14. Trap the King by one of the given Set of pieces

          
15. Sleep Sort – The King of Laziness / Sorting while Sleeping

          
16. Print all Knight's tour possible from a starting point on NxN chessboard

          
17. Find position of Queen in chessboard from given attack lines of queen

          
18. Puzzle | Program to find number of squares in a chessboard

          
19. Save from Bishop in chessboard

          
20. Range and Update Query for Chessboard Pieces

          
21. Count of squares reachable by a Bishop initially placed at top left on a given NxM chessboard

          
22. Maximum bishops that can be placed on N*N chessboard

          
23. Ways to place K bishops on an N×N chessboard so that no two attack

          
24. Check if the given chessboard is valid or not

          
25. Number of blocks in a chessboard a knight can move to in exactly k moves