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[4], arr[5]) i.e. (5, 4)
i + j = arr[i] + arr[j] => 4 + 5 = 5 + 4



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

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

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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.

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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)); 
    
   

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


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

filter_none

edit
close

play_arrow

link
brightness_4
code

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));
    }
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


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.