计算对数(i，j)，以使arr [i]可被arr [j]整除或arr [j]被arr [i]整除

给定N个整数的数组arr [] ，任务是查找无序索引对(i，j)的数量，以使i！= j且0 <= i 且arr [i]可以被整除arr [j]或arr [j]可被arr [i]整除。

例子：

Input: arr[] = {2, 4}
Output: 1
(0, 1) is the only index pair possible.

Input: arr[] = {3, 2, 4, 2, 6}
Output: 6
Possible pairs are (0, 4), (1, 2), (1, 3), (1, 4), (2, 3) and (3, 4).

方法：想法是从数组中找到最大元素，并使用变量count存储无序对的数量，使用数组freq []存储数组元素的频率。现在遍历数组，并为每个元素找到可被数组的第i个数整除且小于或等于数组中最大数的数字。如果数组中存在数字，则更新变量count 。

下面是上述方法的实现：

C++

// C++ implenetation of the approach
#include 
using namespace std;
  
// Function to find number of unordered pairs
int freqPairs(int arr[], int n)
{
  
    // Maximum element from the array
    int max = *(std::max_element(arr, arr + n));
  
    // Array to store the frequency of each
    // element
    int freq[max + 1] = { 0 };
  
    // Stores the number of unordered pairs
    int count = 0;
  
    // Store the frequency of each element
    for (int i = 0; i < n; i++)
        freq[arr[i]]++;
  
    // Find the number of unordered pairs
    for (int i = 0; i < n; i++) {
        for (int j = 2 * arr[i]; j <= max; j += arr[i]) {
  
            // If the number j divisible by ith element
            // is present in the array
            if (freq[j] >= 1)
                count += freq[j];
        }
  
        // If the ith element of the array
        // has frequency more than one
        if (freq[arr[i]] > 1) {
            count += freq[arr[i]] - 1;
            freq[arr[i]]--;
        }
    }
  
    return count;
}
  
// Driver code
int main()
{
  
    int arr[] = { 3, 2, 4, 2, 6 };
    int n = (sizeof(arr) / sizeof(arr[0]));
  
    cout << freqPairs(arr, n);
  
    return 0;
}

Java

import java.util.Arrays;
  
// Java implementation of the approach
class GFG
{
  
    // Function to find number of unordered pairs
    static int freqPairs(int arr[], int n) 
    {
  
        // Maximum element from the array
        int max = Arrays.stream(arr).max().getAsInt();
  
        // Array to store the frequency of each
        // element
        int freq[] = new int[max + 1];
  
        // Stores the number of unordered pairs
        int count = 0;
  
        // Store the frequency of each element
        for (int i = 0; i < n; i++) 
        {
            freq[arr[i]]++;
        }
  
        // Find the number of unordered pairs
        for (int i = 0; i < n; i++) 
        {
            for (int j = 2 * arr[i]; j <= max; j += arr[i])
            {
  
                // If the number j divisible by ith element
                // is present in the array
                if (freq[j] >= 1) 
                {
                    count += freq[j];
                }
            }
  
            // If the ith element of the array
            // has frequency more than one
            if (freq[arr[i]] > 1) 
            {
                count += freq[arr[i]] - 1;
                freq[arr[i]]--;
            }
        }
  
        return count;
    }
  
    // Driver code
    public static void main(String[] args) 
    {
        int arr[] = {3, 2, 4, 2, 6};
        int n = arr.length;
  
        System.out.println(freqPairs(arr, n));
    }
}
  
// This code has been contributed by 29AjayKumar

Python3

# Python 3 implenetation of the approach
  
# Function to find number of unordered pairs
def freqPairs(arr, n):
      
    # Maximum element from the array
    max = arr[0]
    for i in range(len(arr)):
        if arr[i] > max:
            max = arr[i]
  
    # Array to store the frequency of 
    # each element
    freq = [0 for i in range(max + 1)] 
  
    # Stores the number of unordered pairs
    count = 0
  
    # Store the frequency of each element
    for i in range(n):
        freq[arr[i]] += 1
  
    # Find the number of unordered pairs
    for i in range(n):
        for j in range(2 * arr[i], 
                           max + 1, arr[i]):
              
            # If the number j divisible by ith 
            # element is present in the array
            if (freq[j] >= 1):
                count += freq[j]
  
        # If the ith element of the array
        # has frequency more than one
        if (freq[arr[i]] > 1):
            count += freq[arr[i]] - 1
            freq[arr[i]] -= 1
  
    return count
  
# Driver code
if __name__ == '__main__':
    arr = [3, 2, 4, 2, 6]
    n = len(arr)
  
    print(freqPairs(arr, n))
  
# This code is contributed by
# Surendra_Gangwar

C#

// C# implementation of the approach
using System;
using System.Linq;
  
class GFG 
{ 
  
    // Function to find number of unordered pairs 
    static int freqPairs(int []arr, int n) 
    { 
  
        // Maximum element from the array 
        int max = arr.Max(); 
  
        // Array to store the frequency of each 
        // element 
        int []freq = new int[max + 1]; 
  
        // Stores the number of unordered pairs 
        int count = 0; 
  
        // Store the frequency of each element 
        for (int i = 0; i < n; i++) 
        { 
            freq[arr[i]]++; 
        } 
  
        // Find the number of unordered pairs 
        for (int i = 0; i < n; i++) 
        { 
            for (int j = 2 * arr[i]; j <= max; j += arr[i]) 
            { 
  
                // If the number j divisible by ith element 
                // is present in the array 
                if (freq[j] >= 1) 
                { 
                    count += freq[j]; 
                } 
            } 
  
            // If the ith element of the array 
            // has frequency more than one 
            if (freq[arr[i]] > 1) 
            { 
                count += freq[arr[i]] - 1; 
                freq[arr[i]]--; 
            } 
        } 
  
        return count; 
    } 
  
    // Driver code 
    public static void Main(String []args) 
    { 
        int []arr = {3, 2, 4, 2, 6}; 
        int n = arr.Length; 
  
        Console.WriteLine(freqPairs(arr, n)); 
    } 
} 
  
// This code has been contributed by Arnab Kundu

PHP

= 1) 
                $count += $freq[$j]; 
        } 
  
        // If the ith element of the array 
        // has frequency more than one 
        if ($freq[$arr[$i]] > 1)
        { 
            $count += $freq[$arr[$i]] - 1; 
            $freq[$arr[$i]]--; 
        } 
    } 
  
    return $count; 
} 
  
// Driver code 
$arr = array(3, 2, 4, 2, 6); 
$n = count($arr);
  
echo freqPairs($arr, $n); 
  
// This code is contributed by Ryuga
?>

输出：

6