# Count pair of bishops that will attack each other on a N x N chessboard

• Last Updated : 06 Dec, 2021

Given a N x N chessboard and the position of X bishops on it, the task is to calculate the count of pairs of bishops such that they attack each other. Note that while considering a pair of bishops, all the other bishops are not considered to be on the board.

Example:

Input: N = 5, bishops[][] = {{2, 1}, {3, 2}, {2, 3}}
Output: 2
Explanation: The bishops on the positions {2, 1} and {3, 2} and bishops on the positions {3, 2} and {2, 3} attack each other.

Input: N = 10, bishops[][] = {{1, 1}, {1, 5}, {3, 3}, {5, 1}, {5, 5}}
Output: 6

Approach: The given problem can be solved using basic combinatorics. Since all the bishops that lie on the same diagonal will attack each other, all possible pairs of bishops that are on the same diagonal that can be formed will attack each other. Therefore, traverse the matrix for all diagonals in both left and right directions and count the number of bishops on the current diagonal in a variable cnt. Now for each diagonal, the number of attacking bishops will be cntC2.

Below is the implementation of the above approach:

## C++

 `#include ``using` `namespace` `std;` `int` `board[20][20];` `int` `countPairs(``int` `N, vector > bishops)``{``    ``// Set all bits to 0``    ``memset``(board, 0, ``sizeof``(board));` `    ``// Set all the bits``    ``// having bishop to 1``    ``for` `(``int` `i = 0; i < bishops.size(); i++) {``        ``board[bishops[i].first][bishops[i].second] = 1;``    ``}` `    ``// Stores the final answer``    ``int` `ans = 0;` `    ``// Loop to traverse the matrix``    ``// diagonally in left direction``    ``for` `(``int` `s = 2; s <= 2 * N; s++) {` `        ``// Stores count of bishop``        ``// in the current diagonal``        ``int` `cnt = 0;` `        ``for` `(``int` `i = 1, j = s - i;``             ``max(i, j) <= min(N, s - 1); i++, j--) {``            ``if` `(board[j][i - j] == 1)` `                ``// Update cnt``                ``cnt++;``        ``}` `        ``// Update the answer``        ``if` `(cnt > 1)``            ``ans += ((cnt + 1) * cnt) / 2;``    ``}` `    ``// Loop to traverse the matrix``    ``// diagonally in right direction``    ``for` `(``int` `s = 2; s <= 2 * N; s++) {` `        ``// Stores count of bishop``        ``// in the current diagonal``        ``int` `cnt = 0;` `        ``for` `(``int` `i = 1, j = s - i;``             ``max(i, j) <= min(N, s - 1); i++, j--) {``            ``if` `(board[i][N - j + 1] == 1)` `                ``// Update cnt``                ``cnt++;``        ``}` `        ``// Update the answer``        ``if` `(cnt > 1)``            ``ans += ((cnt + 1) * cnt) / 2;``    ``}` `    ``// Return answer``    ``return` `ans;``}` `// Driver code``int` `main()``{``    ``int` `N = 10;``    ``vector > bishops = {``        ``{ 1, 1 }, { 1, 5 }, { 3, 3 }, { 5, 1 }, { 5, 5 }``    ``};` `    ``cout << countPairs(N, bishops);` `    ``return` `0;``}`

## Java

 `import` `java.util.*;``class` `GFG``{``  ``static` `int` `[][]board = ``new` `int``[``20``][``20``];` `  ``static` `int` `countPairs(``int` `N, ``int``[][] bishops)``  ``{` `    ``// Set all the bits``    ``// having bishop to 1``    ``for` `(``int` `i = ``0``; i < bishops.length; i++) {``      ``board[bishops[i][``0``]][bishops[i][``1``]] = ``1``;``    ``}` `    ``// Stores the final answer``    ``int` `ans = ``0``;` `    ``// Loop to traverse the matrix``    ``// diagonally in left direction``    ``for` `(``int` `s = ``2``; s <= ``2` `* N; s++) {` `      ``// Stores count of bishop``      ``// in the current diagonal``      ``int` `cnt = ``0``;` `      ``for` `(``int` `i = ``1``, j = s - i;``           ``Math.max(i, j) <= Math.min(N, s - ``1``)&&i-j>``0``; i++, j--) {``        ``if` `(board[j][i - j] == ``1``)` `          ``// Update cnt``          ``cnt++;``      ``}` `      ``// Update the answer``      ``if` `(cnt > ``1``)``        ``ans += ((cnt + ``1``) * cnt) / ``2``;``    ``}` `    ``// Loop to traverse the matrix``    ``// diagonally in right direction``    ``for` `(``int` `s = ``2``; s <= ``2` `* N; s++) {` `      ``// Stores count of bishop``      ``// in the current diagonal``      ``int` `cnt = ``0``;` `      ``for` `(``int` `i = ``1``, j = s - i;``           ``Math.max(i, j) <= Math.min(N, s - ``1``); i++, j--) {``        ``if` `(board[i][N - j + ``1``] == ``1``)` `          ``// Update cnt``          ``cnt++;``      ``}` `      ``// Update the answer``      ``if` `(cnt > ``1``)``        ``ans += ((cnt + ``1``) * cnt) / ``2``;``    ``}` `    ``// Return answer``    ``return` `ans;``  ``}` `  ``// Driver code``  ``public` `static` `void` `main(String[] args)``  ``{``    ``int` `N = ``10``;``    ``int``[][] bishops = {``      ``{ ``1``, ``1` `}, { ``1``, ``5` `}, { ``3``, ``3` `}, { ``5``, ``1` `}, { ``5``, ``5` `}``    ``};` `    ``System.out.print(countPairs(N, bishops));` `  ``}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python program for above approach``board ``=` `[[``0` `for` `i ``in` `range``(``20``)] ``for` `j ``in` `range``(``20``)]` `def` `countPairs(N, bishops):` `    ``# Set all the bits``    ``# having bishop to 1``    ``for` `i ``in` `range``(``len``(bishops)):``        ``board[bishops[i][``0``]][bishops[i][``1``]] ``=` `1` `    ``# Stores the final answer``    ``ans ``=` `0` `    ``# Loop to traverse the matrix``    ``# diagonally in left direction``    ``for` `s ``in` `range``(``2``, (``2` `*` `N) ``+` `1``):` `        ``# Stores count of bishop``        ``# in the current diagonal``        ``cnt ``=` `0` `        ``i ``=` `1``        ``j ``=` `s ``-` `i``        ``while``(``max``(i, j) <``=` `min``(N, s ``-` `1``)):``            ``if` `(board[j][i ``-` `j] ``=``=` `1``):``                ``# Update cnt``                ``cnt ``+``=` `1``            ``i ``+``=` `1``            ``j ``-``=` `1` `        ``# Update the answer``        ``if` `(cnt > ``1``):``            ``ans ``+``=` `((cnt ``+` `1``) ``*` `cnt) ``/``/` `2` `    ``# Loop to traverse the matrix``    ``# diagonally in right direction``    ``for` `s ``in` `range``(``2``, (``2` `*` `N) ``+` `1``):` `        ``# Stores count of bishop``        ``# in the current diagonal``        ``cnt ``=` `0` `        ``i ``=` `1``        ``j ``=` `s ``-` `i``        ``while``(``max``(i, j) <``=` `min``(N, s ``-` `1``)):``           ` `            ``if` `(board[i][N ``-` `j ``+` `1``] ``=``=` `1``):``                ``# Update cnt``                ``cnt ``+``=` `1``            ``i ``+``=` `1``            ``j ``-``=` `1` `        ``# Update the answer``        ``if` `(cnt > ``1``):``            ``ans ``+``=` `((cnt ``+` `1``) ``*` `cnt) ``/``/` `2` `    ``# Return answer``    ``return` `ans` `# Driver code``N ``=` `10``bishops ``=` `[[``1``, ``1``], [``1``, ``5``], [``3``, ``3``], [``5``, ``1``], [``5``, ``5``]]``print``(countPairs(N, bishops))` `# This code is contributed by gfgking`

## C#

 `using` `System;``class` `GFG``{``    ``static` `int``[,] board = ``new` `int``[20,20];``    ``static` `int` `countPairs(``int` `N, ``int``[,] bishops)``    ``{` `        ``// Set all the bits``        ``// having bishop to 1``        ``for` `(``int` `i = 0; i < bishops.GetLength(0); i++)``        ``{``            ``board[bishops[i,0], bishops[i,1]] = 1;``        ``}` `        ``// Stores the final answer``        ``int` `ans = 0;` `        ``// Loop to traverse the matrix``        ``// diagonally in left direction``        ``for` `(``int` `s = 2; s <= 2 * N; s++)``        ``{` `            ``// Stores count of bishop``            ``// in the current diagonal``            ``int` `cnt = 0;` `            ``for` `(``int` `i = 1, j = s - i;``                 ``Math.Max(i, j) <= Math.Min(N, s - 1) && i - j > 0; i++, j--)``            ``{``                ``if` `(board[j,i - j] == 1)` `                    ``// Update cnt``                    ``cnt++;``            ``}` `            ``// Update the answer``            ``if` `(cnt > 1)``                ``ans += ((cnt + 1) * cnt) / 2;``        ``}` `        ``// Loop to traverse the matrix``        ``// diagonally in right direction``        ``for` `(``int` `s = 2; s <= 2 * N; s++)``        ``{` `            ``// Stores count of bishop``            ``// in the current diagonal``            ``int` `cnt = 0;` `            ``for` `(``int` `i = 1, j = s - i;``                 ``Math.Max(i, j) <= Math.Min(N, s - 1); i++, j--)``            ``{``                ``if` `(board[i,N - j + 1] == 1)` `                    ``// Update cnt``                    ``cnt++;``            ``}` `            ``// Update the answer``            ``if` `(cnt > 1)``                ``ans += ((cnt + 1) * cnt) / 2;``        ``}` `        ``// Return answer``        ``return` `ans;``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``int` `N = 10;``        ``int``[,] bishops = ``new` `int``[5, 2]{{ 1, 1 }, { 1, 5 }, { 3, 3 }, { 5, 1 }, { 5, 5 }};` `        ``Console.Write(countPairs(N, bishops));` `    ``}``}` `// This code is contributed by Saurabh Jaiswal`

## Javascript

 ``

Output

`6`

Time Complexity: O(N * N)
Auxiliary Space: O(N * N)

My Personal Notes arrow_drop_up