# 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:

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] – pawn), (knights[i] – pawn) } 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[],` `                         ``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]` `                    ``- pawn);`   `        ``// Stores absolute difference of Y` `        ``// co-ordinate of i-th knight and pawn` `        ``int` `Y = ``abs``(knights[i]` `                    ``- pawn);`   `        ``// 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[] = { { 0, 4 }, { 4, 5 }, ` `                         ``{ 1, 4 }, { 3, 1 } };`   `    ``int` `pawn[] = { 2, 3 };`   `    ``// Stores total count of knights` `    ``int` `M = ``sizeof``(knights)` `            ``/ ``sizeof``(knights);`   `    ``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); `   `      ``// Stores absolute difference of Y ` `      ``// co-ordinate of i-th knight and pawn ` `      ``int` `Y = Math.Abs(knights[i, 1] - pawn); `   `      ``// 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 :