Open in App
Not now

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

• Difficulty Level : Hard
• Last Updated : 17 Oct, 2022

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:
The only possible pair is (arr[4], arr[5]) i.e. (5, 4)
i + j = arr[i] + arr[j] => 4 + 5 = 5 + 4

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

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 the count = count + 1. Print the count at 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[0]);` `    ``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

 ``

Javascript

 ``

Output

`4`

Time Complexity: O(n2)
Auxiliary Space: O(1)

Efficient Approach:

1. Reduce i + j = arr[i] + arr[j] to (arr[i] – i) = -(arr[j] – j). Now, the problem is reduced 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 between x and -x will be count = count + (frequency(x) * frequency(-x)).
5. Print the count at the end.

Below is the implementation of the above approach:

C++

 `#include ` `#include ` `using` `namespace` `std;`   `// Function to return the count of pairs that` `// satisfy the given condition` `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` `    ``unordered_map<``int``, ``int``> negMap;`   `    ``// HashMap for storing the frequency of` `    ``// positive elements (including 0)` `    ``map<``int``, ``int``> posMap;` `    ``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.count(arr[i]))` `                ``negMap.insert(` `                    ``{ arr[i],` `                      ``negMap.find(arr[i])->second + 1 });` `            ``else`   `                ``// Else set the frequency to 1` `                ``negMap.insert({ arr[i], 1 });` `        ``}`   `        ``// For positive elements (including 0)` `        ``else` `{`   `            ``// If HashMap already contains the integer` `            ``// then increment its frequency by 1` `            ``if` `(posMap.count(arr[i]))` `                ``posMap.insert(` `                    ``{ arr[i],` `                      ``posMap.find(arr[i])->second + 1 });` `            ``else`   `                ``// Else set the frequency to 1` `                ``posMap.insert({ arr[i], 1 });` `        ``}` `    ``}`   `    ``// To store the count of valid pairs` `    ``int` `count = 0;`   `    ``for` `(``auto` `itr = posMap.begin(); itr != posMap.end();` `         ``++itr) {` `        ``int` `posVal = itr->second;`   `        ``// If an equivalent -ve element is found for` `        ``// the current +ve element` `        ``if` `(negMap.count(-itr->first)) {` `            ``int` `negVal = negMap.find(-itr->first)->second;`   `            ``// Add all possible pairs to the count` `            ``count += (negVal * posVal);` `        ``}` `    ``}`   `    ``// Return the count` `    ``return` `count;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `arr[] = { 8, 4, 2, 1, 5, 4, 2, 1, 2, 3 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``cout << countValidPairs(arr, n);` `}`   `// This code is contributed by ApurvaRaj`

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`

C#

 `// C# program to implement ` `// the above approach` `using` `System;` `using` `System.Collections.Generic;` `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 described in the approach` `  ``for` `(i = 0; i < n; i++)` `    ``arr[i] -= i;`   `  ``// Dictionary for storing the ` `  ``// frequency of negative elements` `  ``Dictionary<``int``, ` `             ``int``> negMap = ` `             ``new` `Dictionary<``int``,` `                            ``int``>();`   `  ``// Dictionary for storing the ` `  ``// frequency of positive elements ` `  ``// (including 0)` `  ``Dictionary<``int``, ` `             ``int``> posMap = ` `             ``new` `Dictionary<``int``,` `                            ``int``>();` `  ``for` `(i = 0; i < n; i++) ` `  ``{` `    ``// For negative elements` `    ``if` `(arr[i] < 0) ` `    ``{` `      ``// If Dictionary already ` `      ``// contains the integer then ` `      ``// increment its frequency by 1` `      ``if` `(negMap.ContainsKey(arr[i]))` `        ``negMap[arr[i]] = negMap[arr[i]] + 1;` `      ``else`   `        ``// Else set the frequency to 1` `        ``negMap.Add(arr[i], 1);` `    ``}`   `    ``// For positive elements (including 0)` `    ``else` `    ``{` `      ``// If Dictionary already contains ` `      ``// the integer then increment its ` `      ``// frequency by 1` `      ``if` `(posMap.ContainsKey(arr[i]))` `        ``posMap.Add(arr[i], posMap[arr[i]] + 1);` `      ``else`   `        ``// Else set the frequency to 1` `        ``posMap.Add(arr[i], 1);` `    ``}` `  ``}`   `  ``// To store the count of valid pairs` `  ``int` `count = 0;`   `  ``foreach` `(``int` `posKey ``in` `posMap.Keys) ` `  ``{` `    ``int` `posVal = posMap[posKey];`   `    ``// If an equivalent -ve element ` `    ``// is found for the current +ve element` `    ``if` `(negMap.ContainsKey(-posKey)) ` `    ``{` `      ``int` `negVal = negMap[-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;` `  ``Console.WriteLine(countValidPairs(arr, n));` `}` `}`   `// This code is contributed by Rajput-Ji`

Javascript

 ``

Output

`1`

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

My Personal Notes arrow_drop_up
Related Articles