# Count pairs in an array that hold i+j= arr[i]+arr[j]

Given an array of integers arr[], the task is to count all the pairs (arr[i], arr[j]) such that i + j = arr[i] + arr[j] for all 0 ≤ i < j < n.
Note: Pairs (x, y) and (y, x) are considered a single pair.

Examples:

Input: arr[] = {8, 4, 2, 1, 5, 4, 2, 1, 2, 3}
Output: 1
Only possible pair is (arr, arr) i.e. (5, 4)
i + j = arr[i] + arr[j] => 4 + 5 = 5 + 4

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

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Naive Approach: Run two nested loops and check every possible pair for the condition where i + j = arr[i] + arr[j]. If the condition is satisfied then update count = count + 1. Print the count in the end.

Below is the implementation of the above approach:

## C++

 `// C++ program to count all the pairs that ` `// hold the condition i + j = arr[i] + arr[j] ` `#include ` `using` `namespace` `std; ` ` `  `// Function to return the count of pairs that ` `// satisfy the given condition ` `int` `CountPairs(``int` `arr[], ``int` `n) ` `{ ` `    ``int` `count = 0; ` ` `  `    ``// Generate all possible pairs and increment ` `    ``// the count if the condition is satisfied ` `    ``for` `(``int` `i = 0; i < n - 1; i++) { ` `        ``for` `(``int` `j = i + 1; j < n; j++) { ` `            ``if` `((i + j) == (arr[i] + arr[j])) ` `                ``count++; ` `        ``} ` `    ``} ` `    ``return` `count; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `arr[] = { 1, 0, 3, 2 }; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr); ` `    ``cout << CountPairs(arr, n); ` `    ``return` `0; ` `} `

## Java

 `// Java program to count all the pairs that  ` `// hold the condition i + j = arr[i] + arr[j]  ` ` `  `public` `class` `GFG {  ` `     `  `    ``// Function to return the count of pairs that  ` `    ``// satisfy the given condition  ` `    ``static` `int` `CountPairs(``int` `arr[], ``int` `n)  ` `    ``{  ` `        ``int` `count = ``0``;  ` `     `  `        ``// Generate all possible pairs and increment  ` `        ``// the count if the condition is satisfied  ` `        ``for` `(``int` `i = ``0``; i < n - ``1``; i++) {  ` `            ``for` `(``int` `j = i + ``1``; j < n; j++) {  ` `                ``if` `((i + j) == (arr[i] + arr[j]))  ` `                    ``count++;  ` `            ``}  ` `        ``}  ` `        ``return` `count;  ` `    ``}  ` `     `  `    ``// Driver code  ` `    ``public` `static` `void` `main(String args[])  ` `    ``{  ` `        ``int` `arr[] = { ``1``, ``0``, ``3``, ``2` `};  ` `        ``int` `n = arr.length ;  ` `        ``System.out.print(CountPairs(arr, n));  ` `    ``}  ` ` `  `    ``// This code is contributed by Ryuga. ` `}  `

## Python3

 `# Python 3 program to count all the pairs that ` `# hold the condition i + j = arr[i] + arr[j] ` ` `  `# Function to return the count of pairs  ` `# that satisfy the given condition ` `def` `CountPairs(arr, n): ` ` `  `    ``count ``=` `0``; ` ` `  `    ``# Generate all possible pairs and increment ` `    ``# the count if the condition is satisfied ` `    ``for` `i ``in` `range``(n ``-` `1``): ` `        ``for` `j ``in` `range``(i ``+` `1``, n): ` `            ``if` `((i ``+` `j) ``=``=` `(arr[i] ``+` `arr[j])): ` `                ``count ``+``=` `1``; ` `    ``return` `count; ` ` `  `# Driver code ` `arr ``=` `[ ``1``, ``0``, ``3``, ``2` `]; ` `n ``=` `len``(arr); ` `print``(CountPairs(arr, n)); ` ` `  `# This code is contributed  ` `# by Akanksha Rai `

## C#

 `using` `System; ` ` `  `// C# program to count all the pairs that  ` `// hold the condition i + j = arr[i] + arr[j]  ` `  `  `public` `class` `GFG {  ` `      `  `    ``// Function to return the count of pairs that  ` `    ``// satisfy the given condition  ` `    ``static` `int` `CountPairs(``int``[] arr, ``int` `n)  ` `    ``{  ` `        ``int` `count = 0;  ` `      `  `        ``// Generate all possible pairs and increment  ` `        ``// the count if the condition is satisfied  ` `        ``for` `(``int` `i = 0; i < n - 1; i++) {  ` `            ``for` `(``int` `j = i + 1; j < n; j++) {  ` `                ``if` `((i + j) == (arr[i] + arr[j]))  ` `                    ``count++;  ` `            ``}  ` `        ``}  ` `        ``return` `count;  ` `    ``}  ` `      `  `    ``// Driver code  ` `    ``public` `static` `void` `Main()  ` `    ``{  ` `        ``int``[] arr = { 1, 0, 3, 2 };  ` `        ``int` `n = arr.Length ;  ` `        ``Console.Write(CountPairs(arr, n));  ` `    ``}  ` `  `  `}  `

## PHP

 ` `

Output:

```4
```

Efficient Approach:

1. Reduce i + j = arr[i] + arr[j] to (arr[i] – i) = -(arr[j] – j). Now, the problem reduces to finding all the pairs of the form (x, -x).
2. So, update all the elements of the array as arr[i] = arr[i] – i according to the reduction from step 1.
3. In order to count all the pairs of the form (x, -x), save the frequencies of all the negative elements into a HashMap named negMap and of all the positive elements (including 0) into posMap.
4. Now, for every frequency in posMap say x, find the frequency of -x in negMap. So, all the possible pairs among x and -x will be count = count + (frequency(x) * frequency(-x)).
5. Print the count in the end.

Below is the implementation of the above approach:

## Java

 `import` `java.util.HashMap; ` `import` `java.util.Map; ` `public` `class` `GFG { ` ` `  `    ``// Function to return the count of pairs that ` `    ``// satisfy the given condition ` `    ``static` `int` `countValidPairs(``int` `arr[], ``int` `n) ` `    ``{ ` ` `  `        ``int` `i; ` ` `  `        ``// Update all the elements as describde ` `        ``// in the approach ` `        ``for` `(i = ``0``; i < n; i++) ` `            ``arr[i] -= i; ` ` `  `        ``// HashMap for storing the frequency of ` `        ``// negative elements ` `        ``Map negMap = ``new` `HashMap<>(); ` ` `  `        ``// HashMap for storing the frequency of ` `        ``// positive elements (including 0) ` `        ``Map posMap = ``new` `HashMap<>(); ` `        ``for` `(i = ``0``; i < n; i++) { ` ` `  `            ``// For negative elements ` `            ``if` `(arr[i] < ``0``) { ` ` `  `                ``// If HashMap already contains the integer ` `                ``// then increment its frequency by 1 ` `                ``if` `(negMap.containsKey(arr[i])) ` `                    ``negMap.put(arr[i], negMap.get(arr[i]) + ``1``); ` `                ``else` ` `  `                    ``// Else set the frequency to 1 ` `                    ``negMap.put(arr[i], ``1``); ` `            ``} ` ` `  `            ``// For positive elements (including 0) ` `            ``else` `{ ` ` `  `                ``// If HashMap already contains the integer ` `                ``// then increment its frequency by 1 ` `                ``if` `(posMap.containsKey(arr[i])) ` `                    ``posMap.put(arr[i], posMap.get(arr[i]) + ``1``); ` `                ``else` ` `  `                    ``// Else set the frequency to 1 ` `                    ``posMap.put(arr[i], ``1``); ` `            ``} ` `        ``} ` ` `  `        ``// To store the count of valid pairs ` `        ``int` `count = ``0``; ` ` `  `        ``for` `(``int` `posKey : posMap.keySet()) { ` `            ``int` `posVal = posMap.get(posKey); ` ` `  `            ``// If an equivalent -ve element is found for ` `            ``// the current +ve element ` `            ``if` `(negMap.containsKey(-posKey)) { ` `                ``int` `negVal = negMap.get(-posKey); ` ` `  `                ``// Add all possible pairs to the count ` `                ``count += (negVal * posVal); ` `            ``} ` `        ``} ` ` `  `        ``// Return the count ` `        ``return` `count; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``int` `arr[] = { ``8``, ``4``, ``2``, ``1``, ``5``, ``4``, ``2``, ``1``, ``2``, ``3` `}; ` `        ``int` `n = arr.length; ` `        ``System.out.println(countValidPairs(arr, n)); ` `    ``} ` `} `

## Python3

 `# Function to return the count of pairs that ` `# satisfy the given condition ` `def` `countValidPairs(arr, n): ` `    ``i ``=` `0` ` `  `    ``# Update all the elements as described ` `    ``# in the approach ` `    ``for` `i ``in` `range``(n): ` `        ``arr[i] ``-``=` `i ` ` `  `    ``# HashMap for storing the frequency  ` `    ``# of negative elements ` `    ``negMap ``=` `dict``() ` ` `  `    ``# HashMap for storing the frequency of ` `    ``# positive elements (including 0) ` `    ``posMap ``=` `dict``() ` `    ``for` `i ``in` `range``(n): ` ` `  `        ``# For negative elements ` `        ``if` `(arr[i] < ``0``): ` `             `  `            ``# If HashMap already contains the integer ` `            ``# then increment its frequency by 1 ` `            ``negMap[arr[i]] ``=` `negMap.get(arr[i], ``0``) ``+` `1` `         `  `        ``# For positive elements (including 0) ` `        ``else``: ` ` `  `            ``# If HashMap already contains the integer ` `            ``# then increment its frequency by 1 ` `            ``posMap[arr[i]] ``=` `posMap.get(arr[i], ``0``) ``+` `1` ` `  `    ``# To store the count of valid pairs ` `    ``count ``=` `0` ` `  `    ``for` `posKey ``in` `posMap: ` `        ``posVal ``=` `posMap[posKey] ` ` `  `        ``negVal ``=` `0` ` `  `        ``if` `-``posKey ``in` `negMap: ` `            ``negVal ``=` `negMap[``-``posKey] ` ` `  `        ``# Add all possible pairs to the count ` `        ``count ``+``=` `(negVal ``*` `posVal) ` ` `  `    ``# Return the count ` `    ``return` `count ` ` `  `# Driver code ` `arr ``=` `[``8``, ``4``, ``2``, ``1``, ``5``, ``4``, ``2``, ``1``, ``2``, ``3``] ` `n ``=` `len``(arr) ` `print``(countValidPairs(arr, n)) ` ` `  `# This code is contributed  ` `# by mohit kumar `

Output:

```1
```

My Personal Notes arrow_drop_up Always try to improve and willing to learn

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.