Skip to content
Related Articles
Open in App
Not now

Related Articles

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

Improve Article
Save Article
  • Difficulty Level : Hard
  • Last Updated : 17 Oct, 2022
Improve Article
Save Article

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 <iostream>
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




<?php
// PHP 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
function CountPairs(&$arr, $n)
{
    $count = 0;
 
    // Generate all possible pairs and increment
    // the count if the condition is satisfied
    for ($i = 0; $i < $n - 1; $i++)
    {
        for ($j = $i + 1; $j < $n; $j++)
        {
            if (($i + $j) == ($arr[$i] + $arr[$j]))
                $count++;
        }
    }
    return $count;
}
 
// Driver code
$arr = array(1, 0, 3, 2 );
$n = sizeof($arr);
echo(CountPairs($arr, $n));
 
// This code is contributed
// by Shivi_Aggarwal
?>


Javascript




<script>
// Javascript 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
    function CountPairs(arr,n)
    {
        let count = 0;
      
        // Generate all possible pairs and increment
        // the count if the condition is satisfied
        for (let i = 0; i < n - 1; i++) {
            for (let j = i + 1; j < n; j++) {
                if ((i + j) == (arr[i] + arr[j]))
                    count++;
            }
        }
        return count;
    }
     
    // Driver code
    let arr=[1, 0, 3, 2];
    let n = arr.length ;
    document.write(CountPairs(arr, n));
 
 
// This code is contributed by avanitrachhadiya2155
</script>


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 <bits/stdc++.h>
#include <iostream>
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<Integer, Integer> negMap = new HashMap<>();
 
        // HashMap for storing the frequency of
        // positive elements (including 0)
        Map<Integer, Integer> 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




<script>
 
// Function to return the count of pairs that
// satisfy the given condition
function countValidPairs(arr,n)
{
        let 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
        let negMap = new Map();
  
        // HashMap for storing the frequency of
        // positive elements (including 0)
        let posMap = new Map();
        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.has(arr[i]))
                    negMap.set(arr[i], negMap.get(arr[i]) + 1);
                else
  
                    // Else set the frequency to 1
                    negMap.set(arr[i], 1);
            }
  
            // For positive elements (including 0)
            else {
  
                // If HashMap already contains the integer
                // then increment its frequency by 1
                if (posMap.has(arr[i]))
                    posMap.set(arr[i], posMap.get(arr[i]) + 1);
                else
  
                    // Else set the frequency to 1
                    posMap.set(arr[i], 1);
            }
        }
  
        // To store the count of valid pairs
        let count = 0;
  
        for (let posKey of posMap.keys()) {
            let posVal = posMap.get(posKey);
  
            // If an equivalent -ve element is found for
            // the current +ve element
            if (negMap.has(-posKey)) {
                let negVal = negMap.get(-posKey);
  
                // Add all possible pairs to the count
                count += (negVal * posVal);
            }
        }
  
        // Return the count
        return count;
}
 
// Driver code
let arr=[8, 4, 2, 1, 5, 4, 2, 1, 2, 3];
let n = arr.length;
document.write(countValidPairs(arr, n));
 
     
 
// This code is contributed by rag2127
</script>


Output

1

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


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!