# Count pairs from an array having product of their sum and difference equal to 0

Given an array arr[] of size N, the task is to count possible pairs of array elements (arr[i], arr[j]) such that (arr[i] + arr[j]) * (arr[i] – arr[j]) is 0.

Examples:

Input: arr[] = {2, -2, 1, 1}
Output : 2
Explanation:
(arr[0] + arr[1]) * (arr[0] – arr[1]) = 0
(arr[3] + arr[4]) * (arr[3] – arr[4]) = 0

Input: arr[] = {5, 9, -9, -9}
Output : 3

Naive approach:

Generate all the pairs and for each pair check if the given condition holds true, for all such valid pair increment the count.

• Initialise a variable count for storing the answer.
• Generate all the pairs
• Check if the given condition holds true (i.e, arr[i] + arr[j]) * (arr[i] – arr[j]) is 0)
• Increment the count by 1.
• Print the count.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to count required ` `// number of pairs ` `void` `countPairs(``int` `arr[], ``int` `N) ` `{ ` `    ``int` `count = 0; ` ` `  `    ``// Generate all the possible pair ` `    ``for` `(``int` `i = 0; i < N; i++) { ` `        ``for` `(``int` `j = i + 1; j < N; j++) { ` ` `  `            ``// Check if the given condition holds true ` `            ``if` `((arr[i] + arr[j]) * (arr[i] - arr[j]) ` `                ``== 0) { ` `                ``count++; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Print the total count ` `    ``cout << count << endl; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``// Given arr[] ` `    ``int` `arr[] = { 2, -2, 1, 1 }; ` ` `  `    ``// Size of the array ` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]); ` ` `  `    ``// Function Call ` `    ``countPairs(arr, N); ` ` `  `    ``return` `0; ` `}`

## Java

 `import` `java.io.*; ` ` `  `class` `GFG { ` `    ``// Function to count required ` `    ``// number of pairs ` `    ``public` `static` `void` `countPairs(``int``[] arr, ``int` `N) ` `    ``{ ` `        ``int` `count = ``0``; ` ` `  `        ``// Generate all the possible pair ` `        ``for` `(``int` `i = ``0``; i < N; i++) { ` `            ``for` `(``int` `j = i + ``1``; j < N; j++) { ` ` `  `                ``// Check if the given condition holds true ` `                ``if` `((arr[i] + arr[j]) * (arr[i] - arr[j]) ` `                    ``== ``0``) { ` `                    ``count++; ` `                ``} ` `            ``} ` `        ``} ` ` `  `        ``// Print the total count ` `        ``System.out.println(count); ` `    ``} ` ` `  `    ``// Driver Code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``// Given arr[] ` `        ``int``[] arr = { ``2``, -``2``, ``1``, ``1` `}; ` ` `  `        ``// Size of the array ` `        ``int` `N = arr.length; ` ` `  `        ``// Function Call ` `        ``countPairs(arr, N); ` `    ``} ` `}`

## Python3

 `def` `countPairs(arr, N): ` `    ``count ``=` `0` `    ``for` `i ``in` `range``(N): ` `        ``for` `j ``in` `range``(i``+``1``, N): ` `            ``if` `(arr[i] ``+` `arr[j]) ``*` `(arr[i] ``-` `arr[j]) ``=``=` `0``: ` `                ``count ``+``=` `1` `    ``print``(count) ` ` `  `arr ``=` `[``2``, ``-``2``, ``1``, ``1``] ` `N ``=` `len``(arr) ` `countPairs(arr, N) `

## C#

 `using` `System; ` ` `  `public` `class` `Gfg { ` `    ``static` `void` `Main(``string``[] args) ` `    ``{ ` `        ``// Given arr[] ` `        ``int``[] arr = { 2, -2, 1, 1 }; ` ` `  `        ``// Size of the array ` `        ``int` `N = arr.Length; ` ` `  `        ``// Function Call ` `        ``countPairs(arr, N); ` `    ``} ` ` `  `    ``// Function to count required ` `    ``// number of pairs ` `    ``static` `void` `countPairs(``int``[] arr, ``int` `N) ` `    ``{ ` `        ``int` `count = 0; ` ` `  `        ``// Generate all the possible pair ` `        ``for` `(``int` `i = 0; i < N; i++) { ` `            ``for` `(``int` `j = i + 1; j < N; j++) { ` `                ``// Check if the given condition holds true ` `                ``if` `((arr[i] + arr[j]) * (arr[i] - arr[j]) ` `                    ``== 0) { ` `                    ``count++; ` `                ``} ` `            ``} ` `        ``} ` ` `  `        ``// Print the total count ` `        ``Console.WriteLine(count); ` `    ``} ` `}`

## Javascript

 `// Javascript program for the above approach ` ` `  `// Function to count required ` `// number of pairs ` `function` `countPairs(arr, N) ` `{ ` `    ``let count = 0; ` ` `  `    ``// Generate all the possible pair ` `    ``for` `(let i = 0; i < N; i++) { ` `        ``for` `(let j = i + 1; j < N; j++) { ` ` `  `            ``// Check if the given condition holds true ` `            ``if` `((arr[i] + arr[j]) * (arr[i] - arr[j]) ` `                ``== 0) { ` `                ``count++; ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``// Print the total count ` `    ``document.write(count); ` `} ` ` `  `// Driver Code ` `    ``// Given arr[] ` `    ``let arr = [2, -2, 1, 1 ]; ` ` `  `    ``// Size of the array ` `    ``let N = arr.length; ` ` `  `    ``// Function Call ` `    ``countPairs(arr, N); `

Output

`2`

Time Complexity: O(n*n)
Auxiliary Space: O(1)

Approach: It can be observed that the equation (arr[i] + arr[j]) * (arr[i] – arr[j]) = 0 can be reduced to arr[i]2 = arr[j]2. Therefore, the task reduces to counting pairs having absolute value equal. Follow the steps below to solve the problem:

• Initialize an array hash[] to store the frequency of the absolute value of each array element.
• Calculate the count of pairs by adding (hash[x] * (hash[x] – 1))/ 2 for every array distinct absolute values.

Below is the implementation of the above approach:

## C++14

 `// C++ program for the above approach ` `#include ` `using` `namespace` `std; ` ` `  `#define MAXN 100005 ` ` `  `// Function to count required ` `// number of pairs ` `int` `countPairs(``int` `arr[], ``int` `N) ` `{ ` `    ``// Stores count of pairs ` `    ``int` `desiredPairs = 0; ` ` `  `    ``// Initialize hash with 0 ` `    ``int` `hash[MAXN] = { 0 }; ` ` `  `    ``// Count frequency of each element ` `    ``for` `(``int` `i = 0; i < N; i++) { ` `        ``hash[``abs``(arr[i])]++; ` `    ``} ` ` `  `    ``// Calculate desired number of pairs ` `    ``for` `(``int` `i = 0; i < MAXN; i++) { ` `        ``desiredPairs ` `            ``+= ((hash[i]) * (hash[i] - 1)) / 2; ` `    ``} ` ` `  `    ``// Print desired pairs ` `    ``cout << desiredPairs; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``// Given arr[] ` `    ``int` `arr[] = { 2, -2, 1, 1 }; ` ` `  `    ``// Size of the array ` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]); ` ` `  `    ``// Function Call ` `    ``countPairs(arr, N); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program for the above approach ` `import` `java.io.*; ` `import` `java.util.Arrays;  ` ` `  `class` `GFG{ ` `   `  `static` `int` `MAXN = ``100005``; ` ` `  `// Function to count required ` `// number of pairs ` `static` `void` `countPairs(``int` `arr[], ``int` `N) ` `{ ` `     `  `    ``// Stores count of pairs ` `    ``int` `desiredPairs = ``0``; ` ` `  `    ``// Initialize hash with 0 ` `    ``int` `hash[] = ``new` `int``[MAXN]; ` `    ``Arrays.fill(hash, ``0``); ` ` `  `    ``// Count frequency of each element ` `    ``for``(``int` `i = ``0``; i < N; i++)  ` `    ``{ ` `        ``hash[(Math.abs(arr[i]))]++; ` `    ``} ` ` `  `    ``// Calculate desired number of pairs ` `    ``for``(``int` `i = ``0``; i < MAXN; i++) ` `    ``{ ` `        ``desiredPairs += ((hash[i]) *  ` `                         ``(hash[i] - ``1``)) / ``2``; ` `    ``} ` ` `  `    ``// Print desired pairs ` `    ``System.out.print(desiredPairs); ` `}    ` `   `  `// Driver Code ` `public` `static` `void` `main (String[] args)  ` `{ ` `     `  `    ``// Given arr[] ` `    ``int` `arr[] = { ``2``, -``2``, ``1``, ``1` `}; ` ` `  `    ``// Size of the array ` `    ``int` `N = arr.length; ` ` `  `    ``// Function call ` `    ``countPairs(arr, N); ` `} ` `} ` ` `  `// This code is contributed by code_hunt`

## Python3

 `# Python3 program for  ` `# the above approach ` `MAXN ``=` `100005` ` `  `# Function to count required ` `# number of pairs ` `def` `countPairs(arr, N): ` ` `  `    ``# Stores count of pairs ` `    ``desiredPairs ``=` `0` ` `  `    ``# Initialize hash with 0 ` `    ``hash` `=` `[``0``] ``*` `MAXN ` ` `  `    ``# Count frequency of  ` `    ``# each element ` `    ``for` `i ``in` `range``(N): ` `        ``hash``[``abs``(arr[i])] ``+``=` `1` `    `  `    ``# Calculate desired number  ` `    ``# of pairs ` `    ``for` `i ``in` `range``(MAXN): ` `        ``desiredPairs ``+``=` `((``hash``[i]) ``*`  `                         ``(``hash``[i] ``-` `1``)) ``/``/` `2` `     `  `    ``# Print desired pairs ` `    ``print` `(desiredPairs) ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `"__main__"``: ` `   `  `    ``# Given arr[] ` `    ``arr ``=` `[``2``, ``-``2``, ``1``, ``1``] ` ` `  `    ``# Size of the array ` `    ``N ``=` `len``(arr) ` ` `  `    ``# Function Call ` `    ``countPairs(arr, N) ` ` `  `# This code is contributed by Chitranayal `

## C#

 `// C# program for the above approach ` `using` `System; ` ` `  `class` `GFG{ ` `   `  `static` `int` `MAXN = 100005; ` ` `  `// Function to count required ` `// number of pairs ` `static` `void` `countPairs(``int` `[]arr, ``int` `N) ` `{ ` `     `  `    ``// Stores count of pairs ` `    ``int` `desiredPairs = 0; ` ` `  `    ``// Initialize hash with 0 ` `    ``int` `[]hash = ``new` `int``[MAXN]; ` ` `  `    ``// Count frequency of each element ` `    ``for``(``int` `i = 0; i < N; i++)  ` `    ``{ ` `        ``hash[(Math.Abs(arr[i]))]++; ` `    ``} ` ` `  `    ``// Calculate desired number of pairs ` `    ``for``(``int` `i = 0; i < MAXN; i++) ` `    ``{ ` `        ``desiredPairs += ((hash[i]) *  ` `                         ``(hash[i] - 1)) / 2; ` `    ``} ` ` `  `    ``// Print desired pairs ` `    ``Console.Write(desiredPairs); ` `}    ` `   `  `// Driver Code ` `public` `static` `void` `Main(String[] args)  ` `{ ` `     `  `    ``// Given []arr ` `    ``int` `[]arr = { 2, -2, 1, 1 }; ` ` `  `    ``// Size of the array ` `    ``int` `N = arr.Length; ` ` `  `    ``// Function call ` `    ``countPairs(arr, N); ` `} ` `} ` ` `  `// This code is contributed by Amit Katiyar`

## Javascript

 ` `

Output

`2`

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