# Count of pairs in given Array with product of their values equal to sum of their indices (arr[i]*arr[j] = i+j)

Last Updated : 09 Mar, 2022

Given an array arr[] of length N with distinct integers from 1 to 2*N, the task is to count the number of pairs of indices (i, j) such that (i < j) and arr[i] * arr[j] = i + j, i.e. calculate the number of pairs such that their product is equal to their sum of indices.

Examples:

Input: N = 5, arr[] = {3, 1, 5, 9, 2}
Output: 3
Explanation: There are three pairs (i, j) such that (i < j) and arr[i] * arr[j] = i + j (1, 2), (1, 5), (2, 3)

Input: N = 3, arr[] = {6, 1, 5}
Output: 1

Naive Approach: Iterate over all pairs of indices (i, j) with (i < j) and check for each pair if the above condition is satisfied, then increase the answer by 1 otherwise go to the next pair.

Below is the implementation of the above approach:

## C++

 // C++ program for the above approach #include using namespace std;   // Function to find the number of // unique pairs int NumberOfRequiredPairs(int arr[], int N) {       // Variable that with stores number     // of valid pairs     int ans = 0;       // Traverse the array for every     // possible index i     for (int i = 0; i < N; i++)           // Traverse the array for every         // possible j (i < j)         // Please note that the indices         // are used as 1 based indexing         for (int j = i + 1; j < N; j++)             if ((arr[i] * arr[j])                 == ((i + 1) + (j + 1)))                 ans++;       // Return the ans     return ans; }   // Driver Code int main() {     // Given Input     int N = 5;     int arr[] = { 3, 1, 5, 9, 2 };       // Function Call     cout << NumberOfRequiredPairs(arr, N);     return 0; }

## Java

 // Java program for the above approach import java.io.*; class GFG {   // Function to find the number of // unique pairs static int NumberOfRequiredPairs(int arr[], int N) {       // Variable that with stores number     // of valid pairs     int ans = 0;       // Traverse the array for every     // possible index i     for (int i = 0; i < N; i++)           // Traverse the array for every         // possible j (i < j)         // Please note that the indices         // are used as 1 based indexing         for (int j = i + 1; j < N; j++)             if ((arr[i] * arr[j])                 == ((i + 1) + (j + 1)))                 ans++;       // Return the ans     return ans; }   // Driver code public static void main (String[] args) {         // Given Input     int N = 5;     int arr[] = { 3, 1, 5, 9, 2 };       // Function Call     System.out.println(NumberOfRequiredPairs(arr, N)); } }   // This code is contributed by sanjoy_62.

## Python3

 # Python program for the above approach   # Function to find the number of # unique pairs def NumberOfRequiredPairs(arr, N):       # Variable that with stores number     # of valid pairs     ans = 0       # Traverse the array for every     # possible index i     for i in range(N):           # Traverse the array for every         # possible j (i < j)         # Please note that the indices         # are used as 1 based indexing         for j in range(i + 1, N):             if ((arr[i] * arr[j]) == ((i + 1) + (j + 1))):                 ans += 1       # Return the ans     return ans   # Driver Code # Given Input N = 5 arr = [3, 1, 5, 9, 2]   # Function Call print(NumberOfRequiredPairs(arr, N))   # This code is contributed by Saurabh Jaiswal

## C#

 // C# program for the above approach using System; class GFG {   // Function to find the number of // unique pairs static int NumberOfRequiredPairs(int []arr, int N) {       // Variable that with stores number     // of valid pairs     int ans = 0;       // Traverse the array for every     // possible index i     for (int i = 0; i < N; i++)           // Traverse the array for every         // possible j (i < j)         // Please note that the indices         // are used as 1 based indexing         for (int j = i + 1; j < N; j++)             if ((arr[i] * arr[j])                 == ((i + 1) + (j + 1)))                 ans++;       // Return the ans     return ans; }   // Driver code public static void  Main () {         // Given Input     int N = 5;     int []arr = { 3, 1, 5, 9, 2 };       // Function Call     Console.Write(NumberOfRequiredPairs(arr, N)); } }   // This code is contributed by Samim Hossain Mondal.

## Javascript



Output

3

Time Complexity: O(N^2)
Auxiliary Space: O(1)

Efficient Approach : Rewrite the mentioned condition as

arr[j] = (i + j)/arr[i]

Therefore, for each multiple of arr[i], find the respective j and check whether arr[j] is equal to (i + j)/ arr[i]. This approach is efficient because for each i it is required to go through each multiple of i till 2*N. As all numbers in the array are distinct, it can be concluded that the total iterations for calculating j will be like:

N + N/2 + N/3 + N/4 + N/5……

• Initialize the variable ans as 0 to store the answer.
• Iterate over the range [0, N] using the variable i and perform the following steps:
• Initialize the variable k as the value of arr[i].
• Iterate in a while loop till k is less than equal to 2*N and perform the following tasks:
• Initialize the variable j as k-i-1.
• If j is greater than equal to 1 and less than equal to N and arr[j – 1] is equal to k / arr[i] and j is greater than i+1, then increase the value of ans by 1.
• After performing the above steps, print the value of ans as the answer.

Below is the implementation of the above approach:

## C++

 // C++ program for the above approach #include using namespace std;   // Function to find the number of // unique pairs int NumberOfRequiredPairs(int arr[], int N) {       // Variable that with stores     // number of valid pairs     int ans = 0;       // Traverse the array for every     // possible index i     for (int i = 0; i < N; i++) {           // Initialize a dummy variable         // for arr[i]         int k = arr[i];           // We will loop through every         // multiple of arr[i];         // Looping through 2*N because         // the maximum element         // in array can be 2*N         // Please not that i and j are         // in 1 based indexing         while (k <= 2 * N) {               // Calculating j             int j = k - i - 1;               // Now check if this j lies             // between the bounds             // of the array             if (j >= 1 && j <= N) {                   // Checking the required                 // condition                 if ((arr[j - 1] == k / arr[i])                     && j > i + 1) {                     ans++;                 }             }               // Increasing k to its next multiple             k += arr[i];         }     }       // Return the ans     return ans; }   // Driver Code int main() {     // Given Input     int N = 5;     int arr[] = { 3, 1, 5, 9, 2 };       // Function Call     cout << NumberOfRequiredPairs(arr, N);       return 0; }

## Java

 // Java program for the above approach import java.util.*; public class GFG {   // Function to find the number of // unique pairs static int NumberOfRequiredPairs(int arr[], int N) {       // Variable that with stores     // number of valid pairs     int ans = 0;       // Traverse the array for every     // possible index i     for (int i = 0; i < N; i++) {           // Initialize a dummy variable         // for arr[i]         int k = arr[i];           // We will loop through every         // multiple of arr[i];         // Looping through 2*N because         // the maximum element         // in array can be 2*N         // Please not that i and j are         // in 1 based indexing         while (k <= 2 * N) {               // Calculating j             int j = k - i - 1;               // Now check if this j lies             // between the bounds             // of the array             if (j >= 1 && j <= N) {                   // Checking the required                 // condition                 if ((arr[j - 1] == k / arr[i])                     && j > i + 1) {                     ans++;                 }             }               // Increasing k to its next multiple             k += arr[i];         }     }       // Return the ans     return ans; }   // Driver code public static void main (String args[]) {         // Given Input     int N = 5;     int arr[] = { 3, 1, 5, 9, 2 };       // Function Call     System.out.println(NumberOfRequiredPairs(arr, N)); } }   // This code is contributed by Samim Hossain Mondal.

## Python3

 # Python3 program for the above approach   # Function to find the number of # unique pairs def NumberOfRequiredPairs(arr, N) :       # Variable that with stores     # number of valid pairs     ans = 0;       # Traverse the array for every     # possible index i     for i in range(N) :           # Initialize a dummy variable         # for arr[i]         k = arr[i];           # We will loop through every         # multiple of arr[i];         # Looping through 2*N because         # the maximum element         # in array can be 2*N         # Please not that i and j are         # in 1 based indexing         while (k <= 2 * N) :               # Calculating j             j = k - i - 1;               # Now check if this j lies             # between the bounds             # of the array             if (j >= 1 and j <= N) :                   # Checking the required                 # condition                 if ((arr[j - 1] == k // arr[i]) and j > i + 1) :                     ans += 1;               # Increasing k to its next multiple             k += arr[i];       # Return the ans     return ans;   # Driver Code if __name__ == "__main__" :       # Given Input     N = 5;     arr = [ 3, 1, 5, 9, 2 ];       # Function Call     print(NumberOfRequiredPairs(arr, N));       # This code is contributed by AnkThon

## C#

 // C# program for the above approach using System; class GFG {   // Function to find the number of // unique pairs static int NumberOfRequiredPairs(int []arr, int N) {       // Variable that with stores     // number of valid pairs     int ans = 0;       // Traverse the array for every     // possible index i     for (int i = 0; i < N; i++) {           // Initialize a dummy variable         // for arr[i]         int k = arr[i];           // We will loop through every         // multiple of arr[i];         // Looping through 2*N because         // the maximum element         // in array can be 2*N         // Please not that i and j are         // in 1 based indexing         while (k <= 2 * N) {               // Calculating j             int j = k - i - 1;               // Now check if this j lies             // between the bounds             // of the array             if (j >= 1 && j <= N) {                   // Checking the required                 // condition                 if ((arr[j - 1] == k / arr[i])                     && j > i + 1) {                     ans++;                 }             }               // Increasing k to its next multiple             k += arr[i];         }     }       // Return the ans     return ans; }   // Driver code public static void  Main () {         // Given Input     int N = 5;     int []arr = { 3, 1, 5, 9, 2 };       // Function Call     Console.Write(NumberOfRequiredPairs(arr, N)); } }   // This code is contributed by Samim Hossain Mondal.

## Javascript



Output

3

Time Complexity: O(N*log(N))
Auxiliary Space: O(1)

Previous
Next