来自数组的对数，其平均值也存在于数组中

给定一个由N 个整数组成的数组arr[] ，任务是计算数组中不同对(arr[i], arr[j]) 的数量，使得数组中也存在对的平均值。
注意：将(arr[i], arr[j])和(arr[j], arr[i])视为相同的对。

例子：

Input: arr[] = {2, 1, 3}
Output: 1
Explanation: The only one pair whose average is present in the given array is (1, 3) (Average = 2).

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

朴素的方法：按照以下步骤解决问题：

• 初始化一个变量，比如count为0来存储数组中存在平均值的对的所有计数。
• 将所有数组元素插入到集合S 中。
• 遍历在集合S和在集合S的每个元素，生成所有可能的对给定的阵列，并且如果任何对的总和是与在集合中的当前元素然后通过递增1计数的值。
• 完成上述步骤后，打印count的值作为结果对的计数。

下面是上述方法的实现：

C++

// C++ program for the above approach
#include 
using namespace std;
 
// Function to count the number of
// pairs from the array having sum S
int getCountPairs(vector arr, int N, int S)
{
     
    // Stores the total count of
    // pairs whose sum is 2*S
    int count = 0;
 
    // Generate all possible pairs
    // and check their sums
    for(int i = 0; i < arr.size(); i++)
    {
        for(int j = i + 1; j < arr.size(); j++)
        {
             
            // If the sum is S, then
            // increment the count
            if ((arr[i] + arr[j]) == S)
                count++;
        }
    }
 
    // Return the total
    // count of pairs
    return count;
}
 
// Function to count of pairs having
// whose average exists in the array
int countPairs(vector arr, int N)
{
     
    // Initialize the count
    int count = 0;
 
    // Use set to remove duplicates
    unordered_set S;
 
    // Add elements in the set
    for(int i = 0; i < N; i++)
        S.insert(arr[i]);
 
    for(int ele : S)
    {
        int sum = 2 * ele;
 
        // For every sum, count
        // all possible pairs
        count += getCountPairs(arr, N, sum);
    }
 
    // Return the total count
    return count;
}
 
// Driver Code
int main()
{
    vector arr = { 4, 2, 5, 1, 3, 5 };
    int N = arr.size();
    cout << countPairs(arr, N);
 
    return 0;
}
 
// This code is contributed by Kingash

Java

// Java program for the above approach
 
import java.io.*;
import java.util.*;
 
class GFG {
 
    // Function to count the number of
    // pairs from the array having sum S
    public static int getCountPairs(
        int arr[], int N, int S)
    {
        // Stores the total count of
        // pairs whose sum is 2*S
        int count = 0;
 
        // Generate all possible pairs
        // and check their sums
        for (int i = 0;
             i < arr.length; i++) {
 
            for (int j = i + 1;
                 j < arr.length; j++) {
 
                // If the sum is S, then
                // increment the count
                if ((arr[i] + arr[j]) == S)
                    count++;
            }
        }
 
        // Return the total
        // count of pairs
        return count;
    }
 
    // Function to count of pairs having
    // whose average exists in the array
    public static int countPairs(
        int arr[], int N)
    {
        // Initialize the count
        int count = 0;
 
        // Use set to remove duplicates
        HashSet S = new HashSet<>();
 
        // Add elements in the set
        for (int i = 0; i < N; i++)
            S.add(arr[i]);
 
        for (int ele : S) {
 
            int sum = 2 * ele;
 
            // For every sum, count
            // all possible pairs
            count += getCountPairs(
                arr, N, sum);
        }
 
        // Return the total count
        return count;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int arr[] = { 4, 2, 5, 1, 3, 5 };
        int N = arr.length;
        System.out.print(
            countPairs(arr, N));
    }
}

Python3

# Python3 program for the above approach
 
# Function to count the number of
# pairs from the array having sum S
def getCountPairs(arr, N, S):
     
    # Stores the total count of
    # pairs whose sum is 2*S
    count = 0
 
    # Generate all possible pairs
    # and check their sums
    for i in range(len(arr)):
        for j in range(i + 1, len(arr)):
 
            # If the sum is S, then
            # increment the count
            if ((arr[i] + arr[j]) == S):
                count += 1
 
    # Return the total
    # count of pairs
    return count
 
# Function to count of pairs having
# whose average exists in the array
def countPairs(arr, N):
     
    # Initialize the count
    count = 0
 
    # Use set to remove duplicates
    S = set([])
 
    # Add elements in the set
    for i in range(N):
        S.add(arr[i])
 
    for ele in S:
        sum = 2 * ele
 
        # For every sum, count
        # all possible pairs
        count += getCountPairs(arr, N, sum)
 
    # Return the total count
    return count
 
# Driver Code
if __name__ == "__main__":
 
    arr = [ 4, 2, 5, 1, 3, 5 ]
    N = len(arr)
     
    print(countPairs(arr, N))
 
# This code is contributed by ukasp

C#

// C# program for the above approach
using System;
using System.Collections.Generic;
 
public class GFG
{
 
    // Function to count the number of
    // pairs from the array having sum S
    public static int getCountPairs(
        int []arr, int N, int S)
    {
       
        // Stores the total count of
        // pairs whose sum is 2*S
        int count = 0;
 
        // Generate all possible pairs
        // and check their sums
        for (int i = 0;
             i < arr.Length; i++) {
 
            for (int j = i + 1;
                 j < arr.Length; j++) {
 
                // If the sum is S, then
                // increment the count
                if ((arr[i] + arr[j]) == S)
                    count++;
            }
        }
 
        // Return the total
        // count of pairs
        return count;
    }
 
    // Function to count of pairs having
    // whose average exists in the array
    public static int countPairs(
        int []arr, int N)
    {
        // Initialize the count
        int count = 0;
 
        // Use set to remove duplicates
        HashSet S = new HashSet();
 
        // Add elements in the set
        for (int i = 0; i < N; i++)
            S.Add(arr[i]);
 
        foreach (int ele in S) {
 
            int sum = 2 * ele;
 
            // For every sum, count
            // all possible pairs
            count += getCountPairs(
                arr, N, sum);
        }
 
        // Return the total count
        return count;
    }
 
    // Driver Code
    public static void Main(String[] args)
    {
        int []arr = { 4, 2, 5, 1, 3, 5 };
        int N = arr.Length;
        Console.Write(
            countPairs(arr, N));
    }
}
 
// This code is contributed by Princi Singh

Javascript

 
// JavaScript program for the above approach
 
    // Function to count the number of
    // pairs from the array having sum S
    function getCountPairs(
        arr, N, S)
    {
        // Stores the total count of
        // pairs whose sum is 2*S
        let count = 0;
  
        // Generate all possible pairs
        // and check their sums
        for (let i = 0;
             i < arr.length; i++) {
  
            for (let j = i + 1;
                 j < arr.length; j++) {
  
                // If the sum is S, then
                // increment the count
                if ((arr[i] + arr[j]) == S)
                    count++;
            }
        }
  
        // Return the total
        // count of pairs
        return count;
    }
  
    // Function to count of pairs having
    // whose average exists in the array
    function countPairs(arr, N)
    {
        // Letialize the count
        let count = 0;
  
        // Use set to remove duplicates
        let S = [];
  
        // Add elements in the set
        for (let i = 0; i < N; i++)
            S.push(arr[i]);
  
        for (let ele in S) {
  
            let sum = 2 * ele;
  
            // For every sum, count
            // all possible pairs
            count += getCountPairs(
                arr, N, sum);
        }
  
        // Return the total count
        return count;
    }
 
// Driver code
 
         let arr = [ 4, 2, 5, 1, 3, 5 ];
        let N = arr.length;
        document.write(
            countPairs(arr, N));
 
// This code is contributed by code_hunt.

输出：

7

时间复杂度： O(N ³ )
辅助空间： O(N)

高效的方法：上述方法也可以通过将给定数组中所有可能对的总和的频率存储在 HashMap 中并相应地找到数组中每个元素的计数来优化。请按照以下步骤解决问题：

• 初始化一个变量，比如count为0来存储数组中存在平均值的对的所有计数。
• 将所有数组元素插入到集合S 中。
• 初始化一个 HashMap，比如说M ，它存储给定数组中所有可能对的总和的频率。
• 通过将值(M [X] / 2)横穿通过所述一组S和每个元素(比如说X)在集合S更新计数的值。
• 完成上述步骤后，打印count的值作为结果对的计数。

下面是上述方法的实现：

C++

// CPP program for the above approach
#include
using namespace std;
 
    // Function to count the total count
    // of pairs having sum S
    int getCountPairs(int arr[],
                             int N, int S)
    {
        map mp;
 
        // Store the total count of all
        // elements in map mp
        for (int i = 0; i < N; i++) {
 
            mp[arr[i]]++;
        }
 
        // Stores the total count of
        // total pairs
        int twice_count = 0;
 
        // Iterate through each element
        // and increment the count
        for (int i = 0; i < N; i++) {
 
            // If the value (S - arr[i])
            // exists in the map hm
            if (mp.find(S - arr[i]) != mp.end()) {
 
                // Update the twice count
                twice_count += mp[S - arr[i]];
            }
 
            if (S - arr[i] == arr[i])
                twice_count--;
        }
 
        // Return the half of twice_count
        return twice_count / 2;
    }
 
    // Function to count of pairs having
    // whose average exists in the array
    int countPairs(
        int arr[], int N)
    {
        // Stores the total count of
        // pairs
        int count = 0;
 
        // Use set to remove duplicates
        set S;
 
        // Insert all the element in
        // the set S
        for (int i = 0; i < N; i++)
            S.insert(arr[i]);
 
        for (int ele : S) {
 
            int sum = 2 * ele;
 
            // For every sum find the
            // getCountPairs
            count += getCountPairs(
                arr, N, sum);
        }
 
        // Return the total count of
        // pairs
        return count;
    }
 
    // Driver Code
    int main()
    {
        int N = 6;
        int arr[] = { 4, 2, 5, 1, 3, 5 };
        cout<<(countPairs(arr, N));
    }
 
// This code is contributed by ipg2016107.

Java

// Java program for the above approach
 
import java.io.*;
import java.util.*;
 
class GFG {
 
    // Function to count the total count
    // of pairs having sum S
    static int getCountPairs(int arr[],
                             int N, int S)
    {
        HashMap mp
            = new HashMap<>();
 
        // Store the total count of all
        // elements in map mp
        for (int i = 0; i < N; i++) {
 
            // Initialize value to 0,
            // if key not found
            if (!mp.containsKey(arr[i]))
                mp.put(arr[i], 0);
 
            mp.put(arr[i],
                   mp.get(arr[i]) + 1);
        }
 
        // Stores the total count of
        // total pairs
        int twice_count = 0;
 
        // Iterate through each element
        // and increment the count
        for (int i = 0; i < N; i++) {
 
            // If the value (S - arr[i])
            // exists in the map hm
            if (mp.get(S - arr[i])
                != null) {
 
                // Update the twice count
                twice_count += mp.get(
                    S - arr[i]);
            }
 
            if (S - arr[i] == arr[i])
                twice_count--;
        }
 
        // Return the half of twice_count
        return twice_count / 2;
    }
 
    // Function to count of pairs having
    // whose average exists in the array
    public static int countPairs(
        int arr[], int N)
    {
        // Stores the total count of
        // pairs
        int count = 0;
 
        // Use set to remove duplicates
        HashSet S = new HashSet<>();
 
        // Insert all the element in
        // the set S
        for (int i = 0; i < N; i++)
            S.add(arr[i]);
 
        for (int ele : S) {
 
            int sum = 2 * ele;
 
            // For every sum find the
            // getCountPairs
            count += getCountPairs(
                arr, N, sum);
        }
 
        // Return the total count of
        // pairs
        return count;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int N = 6;
        int arr[] = { 4, 2, 5, 1, 3, 5 };
        System.out.println(
            countPairs(arr, N));
    }
}

输出：

7

时间复杂度： O(N ² )
辅助空间： O(N)

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live