Skip to content
Related Articles

Related Articles

Improve Article

Count of unordered pair of indices such that ratio of elements at these indices is same as ratio of indices

  • Last Updated : 18 Oct, 2021
Geek Week

Given an array arr[] of N integers, the task is to find the number of unordered pairs (i, j) in the array such that the ratio of elements at these indices is the same as the ratio of indices (arr[j]/arr[i] = j/i).

Examples:

Input: arr[] = {4, 5, 12, 10, 6}
Output:  2
Explaination: The pairs that follow the given condition are: 

  1. (1, 3) as arr[3] / arr[1] = 12/4 = 3 = 3/1
  2. (2, 4) as arr[4] / arr[2] = 10/5 = 2 = 4/2

Input: arr[] = {5, -2, 4, 20, 25, -6}
Output:
 

Naive Approach: The given problem can be solved by iterating over all the unordered pairs (i, j) in the given array while keeping track of the number of pairs that follow the condition arr[j] / arr[i] = j / i.



Below is the implementation of the above approach:

C++




// C++ program of the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function of find the count of unordered
// pairs (i, j) in the array such that
// arr[j] / arr[i] = j / i.
int countPairs(int arr[], int n)
{
    // Stores the count of valid pairs
    int count = 0;
 
    // Iterating over all possible pairs
    for (int i = 0; i < n - 1; i++) {
        for (int j = i + 1; j < n; j++) {
 
            // Check if the pair is valid
            if ((arr[j] % arr[i] == 0)
                && (j + 1) % (i + 1) == 0
                && (arr[j] / arr[i]
                    == (j + 1) / (i + 1))) {
                count++;
            }
        }
    }
 
    // Return answer
    return count;
}
 
// Driver Code
int main()
{
    int arr[] = { 5, -2, 4, 20, 25, -6 };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    // Function Call
    cout << countPairs(arr, n);
 
    return 0;
}

Java




// Java program of the above approach
import java.util.*;
 
class GFG
{
 
// Function of find the count of unordered
// pairs (i, j) in the array such that
// arr[j] / arr[i] = j / i.
static int countPairs(int arr[], int n)
{
   
    // Stores the count of valid pairs
    int count = 0;
 
    // Iterating over all possible pairs
    for (int i = 0; i < n - 1; i++) {
        for (int j = i + 1; j < n; j++) {
 
            // Check if the pair is valid
            if ((arr[j] % arr[i] == 0)
                && (j + 1) % (i + 1) == 0
                && (arr[j] / arr[i]
                    == (j + 1) / (i + 1))) {
                count++;
            }
        }
    }
 
    // Return answer
    return count;
}
 
// Driver Code
public static void main(String[] args)
{
    int arr[] = { 5, -2, 4, 20, 25, -6 };
    int n = arr.length;
 
    // Function Call
    System.out.print(countPairs(arr, n));
}
}
 
// This code is contributed by shikhasingrajput

Python3




# Python 3 program of the above approach
 
# Function of find the count of unordered
# pairs (i, j) in the array such that
# arr[j] / arr[i] = j / i.
def countPairs(arr, n):
 
    # Stores the count of valid pairs
    count = 0
 
    # Iterating over all possible pairs
    for i in range(n - 1):
        for j in range(i + 1, n):
 
            # Check if the pair is valid
            if ((arr[j] % arr[i] == 0)
                and (j + 1) % (i + 1) == 0
                and (arr[j] // arr[i]
                     == (j + 1) // (i + 1))):
                count += 1
 
    # Return answer
    return count
 
# Driver Code
if __name__ == "__main__":
 
    arr = [5, -2, 4, 20, 25, -6]
    n = len(arr)
 
    # Function Call
    print(countPairs(arr, n))
 
    # This code is contributed by ukasp.

C#




// C# program for the above approach
using System;
 
public class GFG
{
 
// Function of find the count of unordered
// pairs (i, j) in the array such that
// arr[j] / arr[i] = j / i.
static int countPairs(int[] arr, int n)
{
    
    // Stores the count of valid pairs
    int count = 0;
  
    // Iterating over all possible pairs
    for (int i = 0; i < n - 1; i++) {
        for (int j = i + 1; j < n; j++) {
  
            // Check if the pair is valid
            if ((arr[j] % arr[i] == 0)
                && (j + 1) % (i + 1) == 0
                && (arr[j] / arr[i]
                    == (j + 1) / (i + 1))) {
                count++;
            }
        }
    }
  
    // Return answer
    return count;
}   
   
    // Driver Code
    public static void Main (string[] args)
    {
        int[] arr = { 5, -2, 4, 20, 25, -6 };
        int n = arr.Length;
  
        // Function Call
        Console.WriteLine(countPairs(arr, n));
    }
}
 
// This code is contributed by avijitmondal1998.

Javascript




<script>
        // JavaScript Program to implement
        // the above approach
 
        // Function of find the count of unordered
        // pairs (i, j) in the array such that
        // arr[j] / arr[i] = j / i.
        function countPairs(arr, n)
        {
         
            // Stores the count of valid pairs
            let count = 0;
 
            // Iterating over all possible pairs
            for (let i = 0; i < n - 1; i++) {
                for (let j = i + 1; j < n; j++) {
 
                    // Check if the pair is valid
                    if ((arr[j] % arr[i] == 0)
                        && (j + 1) % (i + 1) == 0
                        && (arr[j] / arr[i]
                            == (j + 1) / (i + 1))) {
                        count++;
                    }
                }
            }
 
            // Return answer
            return count;
        }
 
        // Driver Code
 
        let arr = [5, -2, 4, 20, 25, -6];
        let n = arr.length;
        // Function Call
        document.write(countPairs(arr, n));
         
     // This code is contributed by Potta Lokesh
 
    </script>

 
 

Output
3

 

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

 

Efficient Approach: The above approach can be optimized using the observation that the maximum value of y / x for any pair (x, y) that can be reached is N. Also, y must be divisible by x. Therefore, for x in the range [1, N], iterate over all y in the range [1, N] such that y is divisible by x and keep a track of the number of pairs (x, y) such that arr[y] / arr[x] = y / x. This can be done using the Sieve of Eratosthenes.
 
 Below is the implementation of the above approach:

 

C++




// C++ program of the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function of find the count of unordered
// pairs (i, j) in the array such that
// arr[j] / arr[i] = j / i.
int countPairs(int arr[], int n)
{
    // Stores the count of valid pairs
    int count = 0;
 
    // Iterating over all values of
    // x in range [1, N].
    for (int x = 1; x <= n; x++) {
 
        // Iterating over all values
        // of y that are divisible by
        // x in the range [1, N].
        for (int y = 2 * x; y <= n; y += x) {
 
            // Check if the pair is valid
            if ((arr[y - 1] % arr[x - 1] == 0)
                && (arr[y - 1] / arr[x - 1]
                    == y / x)) {
                count++;
            }
        }
    }
 
    // Return answer
    return count;
}
 
// Driver Code
int main()
{
    int arr[] = { 5, -2, 4, 20, 25, -6 };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    // Function Call
    cout << countPairs(arr, n);
 
    return 0;
}

Python3




# Python 3 program of the above approach
 
# Function of find the count of unordered
# pairs (i, j) in the array such that
# arr[j] / arr[i] = j / i.
def countPairs(arr, n):
   
    # Stores the count of valid pairs
    count = 0
 
    # Iterating over all values of
    # x in range [1, N].
    for x in range(1, n + 1, 1):
       
        # Iterating over all values
        # of y that are divisible by
        # x in the range [1, N].
        for y in range(2 * x, n + 1, x):
           
            # Check if the pair is valid
            if ((arr[y - 1] % arr[x - 1] == 0) and (arr[y - 1] // arr[x - 1] == y // x)):
                count += 1
 
    # Return answer
    return count
 
# Driver Code
if __name__ == '__main__':
    arr = [5, -2, 4, 20, 25, -6]
    n = len(arr)
 
    # Function Call
    print(countPairs(arr, n))
     
    # This code is contributed by SURENDRA_GANGWAR.
Output
3

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :