# Count Knights that can attack a given pawn in an N * N board

• Difficulty Level : Easy
• Last Updated : 03 May, 2021

Given a 2D array knights[][] of size N * 2, with each row of the form { X, Y } representing the coordinates of knights, and an array pawn[] representing the coordinates of a pawn in an N * N board, the task is to find the count of knights present in the board that is attacking the pawn.

Examples:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

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

Input: knights[][] = { { 0, 4 }, { 4, 5 }, { 1, 4 }, { 3, 1 } }, pawn[] = { 2, 3 }
Output:
Explanation:
The knights present at coordinate { { 0, 4 }, { 3, 1 } } are attacking the pawn.
Therefore, the required output is 2.

Input: knights[][] = { { 4, 6 }, { 7, 5 }, { 5, 5 } }, pawn[] = { 6, 7 }
Output:
Explanation:
The knights present at coordinate { { 4, 6 }, { 7, 5 }, { 5, 5 } } are attacking the pawn.
Therefore, the required output is 3.

Approach: Follow the steps given below to solve the problem

• Initialize a variable, say cntKnights, to store the count of knights that are attacking the pawn.
• Traverse the knights[][] array using variable i and for every array element knights[i], check if the array { (knights[i][0] – pawn[0]), (knights[i][1] – pawn[1]) } is equal to either { 1, 2 } or { 2, 1 } or not. If found to be true, then increment the value of cntKnights by 1.
• Finally, print the value of cntKnights.

Below is the implementation of the above approach:

## C++

 `// C++ program to implement` `// the above approach`   `#include ` `using` `namespace` `std;`   `// Function to count the knights that are` `// attacking the pawn in an M * M board` `int` `cntKnightsAttackPawn(``int` `knights[][2],` `                         ``int` `pawn[], ``int` `M)` `{` `    ``// Stores count of knights that` `    ``// are attacking the pawn` `    ``int` `cntKnights = 0;`   `    ``// Traverse the knights[][] array` `    ``for` `(``int` `i = 0; i < M; i++) {`   `        ``// Stores absolute difference of X` `        ``// co-ordinate of i-th knight and pawn` `        ``int` `X = ``abs``(knights[i][0]` `                    ``- pawn[0]);`   `        ``// Stores absolute difference of Y` `        ``// co-ordinate of i-th knight and pawn` `        ``int` `Y = ``abs``(knights[i][1]` `                    ``- pawn[1]);`   `        ``// If X is 1 and Y is 2 or` `        ``// X is 2 and Y is 1` `        ``if` `((X == 1 && Y == 2)` `            ``|| (X == 2 && Y == 1)) {`   `            ``// Update cntKnights` `            ``cntKnights++;` `        ``}` `    ``}`   `    ``return` `cntKnights;` `}`   `// Driver Code` `int` `main()` `{`   `    ``int` `knights[][2] = { { 0, 4 }, { 4, 5 }, ` `                         ``{ 1, 4 }, { 3, 1 } };`   `    ``int` `pawn[] = { 2, 3 };`   `    ``// Stores total count of knights` `    ``int` `M = ``sizeof``(knights)` `            ``/ ``sizeof``(knights[0]);`   `    ``cout << cntKnightsAttackPawn(` `        ``knights, pawn, M);`   `    ``return` `0;` `}`

## Java

 `// Java program to implement ` `// the above approach ` `import` `java.io.*;` `import` `java.lang.Math;`   `class` `GFG{`   `// Function to count the knights that are ` `// attacking the pawn in an M * M board ` `static` `int` `cntKnightsAttackPawn(``int` `knights[][], ` `                                ``int` `pawn[], ``int` `M)` `{` `    `  `    ``// Stores count of knights that ` `    ``// are attacking the pawn ` `    ``int` `cntKnights = ``0``;` `    `  `     ``// Traverse the knights[][] array ` `    ``for``(``int` `i = ``0``; i < M; i++) ` `    ``{ ` `        `  `        ``// Stores absolute difference of X ` `        ``// co-ordinate of i-th knight and pawn ` `        ``int` `X = Math.abs(knights[i][``0``] - pawn[``0``]); ` `    `  `        ``// Stores absolute difference of Y ` `        ``// co-ordinate of i-th knight and pawn ` `        ``int` `Y = Math.abs(knights[i][``1``] - pawn[``1``]); ` `    `  `        ``// If X is 1 and Y is 2 or ` `        ``// X is 2 and Y is 1 ` `        ``if` `((X == ``1` `&& Y == ``2``) ||` `            ``(X == ``2` `&& Y == ``1``))` `        ``{ ` `            `  `            ``// Update cntKnights ` `            ``cntKnights++; ` `        ``} ` `    ``} ` `    ``return` `cntKnights; ` `}`   `// Driver code` `public` `static` `void` `main(String[] args)` `{` `    ``int``[][] knights = { { ``0``, ``4` `}, { ``4``, ``5` `}, ` `                        ``{ ``1``, ``4` `}, { ``3``, ``1` `} };` `    `  `    ``int``[] pawn = ``new` `int``[]{``2``, ``3``};` `  `  `    ``// Stores total count of knights ` `    ``int` `M = knights.length;` `    `  `    ``System.out.println(cntKnightsAttackPawn(` `        ``knights, pawn, M));` `}` `}`   `// This code is contributed by vandanakillari54935`

## Python3

 `# Python program to implement` `# the above approach`   `# Function to count the knights that are` `# attacking the pawn in an M * M board` `def` `cntKnightsAttackPawn(knights, pawn, M):` `  `  `    ``# Stores count of knights that` `    ``# are attacking the pawn` `    ``cntKnights ``=` `0``;`   `    ``# Traverse the knights array` `    ``for` `i ``in` `range``(M):`   `        ``# Stores absolute difference of X` `        ``# co-ordinate of i-th knight and pawn` `        ``X ``=` `abs``(knights[i][``0``] ``-` `pawn[``0``]);`   `        ``# Stores absolute difference of Y` `        ``# co-ordinate of i-th knight and pawn` `        ``Y ``=` `abs``(knights[i][``1``] ``-` `pawn[``1``]);`   `        ``# If X is 1 and Y is 2 or` `        ``# X is 2 and Y is 1` `        ``if` `((X ``=``=` `1` `and` `Y ``=``=` `2``) ``or` `(X ``=``=` `2` `and` `Y ``=``=` `1``)):` `          `  `            ``# Update cntKnights` `            ``cntKnights ``+``=` `1``;`   `    ``return` `cntKnights;`   `# Driver code` `if` `__name__ ``=``=` `'__main__'``:` `    ``knights ``=` `[[``0``, ``4``], [``4``, ``5``], [``1``, ``4``], [``3``, ``1``]];`   `    ``pawn ``=` `[``2``, ``3``];`   `    ``# Stores total count of knights` `    ``M ``=` `len``(knights);`   `    ``print``(cntKnightsAttackPawn(knights, pawn, M));`   `# This code is contributed by Amit Katiyar`

## C#

 `// C# program to implement ` `// the above approach ` `using` `System;` `class` `GFG ` `{`   `  ``// Function to count the knights that are ` `  ``// attacking the pawn in an M * M board ` `  ``static` `int` `cntKnightsAttackPawn(``int``[,] knights, ``int``[] pawn, ``int` `M) ` `  ``{ ` `    ``// Stores count of knights that ` `    ``// are attacking the pawn ` `    ``int` `cntKnights = 0; `   `    ``// Traverse the knights[][] array ` `    ``for` `(``int` `i = 0; i < M; i++) { `   `      ``// Stores absolute difference of X ` `      ``// co-ordinate of i-th knight and pawn ` `      ``int` `X = Math.Abs(knights[i, 0] - pawn[0]); `   `      ``// Stores absolute difference of Y ` `      ``// co-ordinate of i-th knight and pawn ` `      ``int` `Y = Math.Abs(knights[i, 1] - pawn[1]); `   `      ``// If X is 1 and Y is 2 or ` `      ``// X is 2 and Y is 1 ` `      ``if` `((X == 1 && Y == 2) ` `          ``|| (X == 2 && Y == 1)) { `   `        ``// Update cntKnights ` `        ``cntKnights++; ` `      ``} ` `    ``} `   `    ``return` `cntKnights; ` `  ``} `   `  ``// Driver code` `  ``static` `void` `Main() ` `  ``{` `    ``int``[,] knights = {{ 0, 4 }, { 4, 5 }, { 1, 4 }, { 3, 1 }}; `   `    ``int``[] pawn = {2, 3}; `   `    ``// Stores total count of knights ` `    ``int` `M = knights.GetLength(0); `   `    ``Console.WriteLine(cntKnightsAttackPawn(knights, pawn, M));` `  ``}` `}`   `// This code is contributed by divyeshrabadiya07`

## Javascript

 ``

Output

`2`

Time Complexity: O(M), where M is the total count number of knights
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Recommended Articles
Page :