给定数组所有对的乘积生成的数组均值

给定一个由N个整数组成的数组arr [] ，任务是查找由给定数组的无序对的乘积形成的数组的均值。

例子：

Input: arr[] = {2, 5, 7}
Output: 19.67
Explanation:
Product of unordered pairs of array arr[] are 2 * 5 = 10, 2 * 7 = 14 and 5 * 7 = 35.
Therefore, the resultant array of product of pairs is {10, 14, 35}.
Mean of the array of product of pairs is 59/3 = 19.67

Input: arr[] = {1, 2, 4, 8}
Output: 11.67
Explanation:
Product of unordered pairs of array arr[] are 1 * 2 = 2, 1 * 4 = 4, 1 * 8 = 8, 2 * 4 = 8, 2 * 8 = 16, 4 * 8 = 32.
Therefore, the resultant array of product of pairs is {2, 4, 8, 8, 16, 32}.
Mean of the array of product of pairs is 70/6 i.e., 11.67

天真的方法：解决问题的最简单方法是生成所有可能的成对的array pairProductArray []，即由数组arr []的无序对的乘积形成的数组。然后，找到pairProductArray []的均值。请按照以下步骤解决问题：

• 生成数组arr []的所有可能的对，并将它们的乘积存储在pairProductArray []中。
• 初始化变量sum来存储pairProductArray []的元素之和。
• 将变量sum除以pairProductArray []的大小即可得到所需的均值。
• 最后，打印总和的值作为结果平均值。

下面是上述方法的实现：

C++

// C++ program for the above approach
 
#include 
using namespace std;
 
// Function to find the mean of pair
// product array of arr[]
float pairProductMean(int arr[], int N)
{
    // Store product of pairs
    vector pairArray;
 
    // Generate all unordered pairs
    for (int i = 0; i < N; i++) {
        for (int j = i + 1; j < N; j++) {
 
            int pairProduct
                = arr[i] * arr[j];
 
            // Store product of pairs
            pairArray.push_back(pairProduct);
        }
    }
 
    // Size of pairArray
    int length = pairArray.size();
 
    // Store sum of pairArray
    float sum = 0;
    for (int i = 0; i < length; i++)
        sum += pairArray[i];
 
    // Stores the mean of pairArray[]
    float mean;
 
    // Find mean of pairArray[]
    if (length != 0)
        mean = sum / length;
    else
        mean = 0;
 
    // Return the resultant mean
    return mean;
}
 
// Driver Code
int main()
{
    // Given array arr[]
    int arr[] = { 1, 2, 4, 8 };
 
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // Function Call
    cout << fixed << setprecision(2)
         << pairProductMean(arr, N);
 
    return 0;
}

Java

// Java program for the
// above approach
import java.util.*;
class GFG{
 
// Function to find the mean
// of pair product array of arr[]
static double  pairProductMean(int arr[],
                               int N)
{
  // Store product of pairs
  Vector pairArray =
         new Vector<>();
 
  // Generate all unordered pairs
  for (int i = 0; i < N; i++)
  {
    for (int j = i + 1; j < N; j++)
    {
      int pairProduct = arr[i] *
                        arr[j];
 
      // Store product of pairs
      pairArray.add(pairProduct);
    }
  }
 
  // Size of pairArray
  int length = pairArray.size();
 
  // Store sum of pairArray
  float sum = 0;
  for (int i = 0; i < length; i++)
    sum += pairArray.get(i);
 
  // Stores the mean of
  // pairArray[]
  float mean;
 
  // Find mean of pairArray[]
  if (length != 0)
    mean = sum / length;
  else
    mean = 0;
 
  // Return the resultant mean
  return mean;
}
 
// Driver Code
public static void main(String[] args)
{
  // Given array arr[]
  int arr[] = {1, 2, 4, 8};
 
  int N = arr.length;
 
  // Function Call
 
  System.out.format("%.2f",
                    pairProductMean(arr, N));
}
}
 
// This code is contributed by shikhasingrajput

Python3

# Python3 program for the
# above approach
 
# Function to find the mean
# of pair product array of arr
def pairProductMean(arr, N):
   
    # Store product of pairs
    pairArray = [];
 
    # Generate all unordered
    # pairs
    for i in range(N):
        for j in range(i + 1, N):
            pairProduct = arr[i] * arr[j];
 
            # Store product of pairs
            pairArray.append(pairProduct);
 
    # Size of pairArray
    length = len(pairArray);
 
    # Store sum of pairArray
    sum = 0;
    for i in range(length):
        sum += pairArray[i];
 
    # Stores the mean of
    # pairArray
    mean = 0;
 
    # Find mean of pairArray
    if (length != 0):
        mean = sum / length;
    else:
        mean = 0;
 
    # Return the resultant
    # mean
    return mean;
 
# Driver Code
if __name__ == '__main__':
   
    # Given array arr
    arr = [1, 2, 4, 8];
 
    N = len(arr);
 
    # Function Call
    print("{0:.2f}".format(
            pairProductMean(arr, N)))
 
# This code is contributed by Rajput-Ji

C#

// C# program for the
// above approach
using System;
using System.Collections.Generic;
class GFG{
 
// Function to find the mean
// of pair product array of []arr
static double  pairProductMean(int []arr,
                               int N)
{
  // Store product of pairs
  List pairArray =
         new List();
 
  // Generate all unordered pairs
  for (int i = 0; i < N; i++)
  {
    for (int j = i + 1; j < N; j++)
    {
      int pairProduct = arr[i] *
                        arr[j];
 
      // Store product of pairs
      pairArray.Add(pairProduct);
    }
  }
 
  // Size of pairArray
  int length = pairArray.Count;
 
  // Store sum of pairArray
  float sum = 0;
  for (int i = 0; i < length; i++)
    sum += pairArray[i];
 
  // Stores the mean of
  // pairArray[]
  float mean;
 
  // Find mean of pairArray[]
  if (length != 0)
    mean = sum / length;
  else
    mean = 0;
 
  // Return the resultant mean
  return mean;
}
 
// Driver Code
public static void Main(String[] args)
{
  // Given array []arr
  int []arr = {1, 2, 4, 8};
 
  int N = arr.Length;
 
  // Function Call
  Console.WriteLine("{0:F2}",
                    pairProductMean(arr,
                                    N));
}
}
 
// This code is contributed by 29AjayKumar

Javascript

 
// Javascript program for the
// above approach
 
    // Function to find the mean
    // of pair product array of arr
    function pairProductMean(arr , N)
    {
        // Store product of pairs
        var pairArray = [];
 
        // Generate all unordered pairs
        for (i = 0; i < N; i++) {
            for (j = i + 1; j < N; j++) {
                var pairProduct = arr[i] * arr[j];
 
                // Store product of pairs
                pairArray.push(pairProduct);
            }
        }
 
        // Size of pairArray
        var length = pairArray.length;
 
        // Store sum of pairArray
        var sum = 0;
        for (i = 0; i < length; i++)
            sum += pairArray[i];
 
        // Stores the mean of
        // pairArray
        var mean;
 
        // Find mean of pairArray
        if (length != 0)
            mean = sum / length;
        else
            mean = 0;
 
        // Return the resultant mean
        return mean;
    }
 
    // Driver Code
     
        // Given array arr
        var arr = [ 1, 2, 4, 8 ];
 
        var N = arr.length;
 
        // Function Call
 
        document.write(pairProductMean(arr, N).toFixed(2));
 
// This code contributed by gauravrajput1
 

输出

11.67

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

高效的方法：该想法是利用每个元素arr [i]与位于元素arr [i]右侧的每个元素arr [j]相乘的事实，更正式地将索引i处的元素与所有元素相乘位于索引j处的元素，使得j> i 。请按照以下步骤解决问题：

• 为给定数组arr []创建一个后缀和数组suffixSumArray [] 。
• 初始化变量res，以存储数组arr []的乘积对之和。
• 迭代数组arr [] ，对于每个位置i都使用arr [i] * suffixSumArray [i + 1]递增res 。
• 将变量res除以N *(N – 1)/ 2 ，这是可能乘积的数量。
• 最后，打印res的值作为结果平均值。

下面是上述方法的实现：

C++

// C++ program for the above approach
#include 
using namespace std;
 
// Function to find the mean of pair
// product array of arr[]
float pairProductMean(int arr[], int N)
{
    // Initializing suffix sum array
    int suffixSumArray[N];
    suffixSumArray[N - 1] = arr[N - 1];
 
    // Build suffix sum array
    for (int i = N - 2; i >= 0; i--) {
        suffixSumArray[i]
            = suffixSumArray[i + 1]
              + arr[i];
    }
 
    // Size of pairProductArray
    int length = (N * (N - 1)) / 2;
 
    // Stores sum of pairProductArray
    float res = 0;
 
    for (int i = 0; i < N - 1; i++) {
        res += arr[i]
               * suffixSumArray[i + 1];
    }
 
    // Store the mean
    float mean;
 
    // Find mean of pairProductArray
    if (length != 0)
        mean = res / length;
    else
        mean = 0;
 
    // Return the resultant mean
    return mean;
}
 
// Driver Code
int main()
{
    // Given array arr[]
    int arr[] = { 1, 2, 4, 8 };
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // Function Call
    cout << fixed << setprecision(2)
         << pairProductMean(arr, N);
 
    return 0;
}

Java

// Java program for the above approach
import java.io.*;
import java.util.*;
 
class GFG{
  
// Function to find the mean of pair
// product array of arr[]
static float pairProductMean(int arr[], int N)
{
     
    // Initializing suffix sum array
    int suffixSumArray[] = new int[N];
    suffixSumArray[N - 1] = arr[N - 1];
  
    // Build suffix sum array
    for(int i = N - 2; i >= 0; i--)
    {
        suffixSumArray[i] = suffixSumArray[i + 1] +
                                       arr[i];
    }
  
    // Size of pairProductArray
    int length = (N * (N - 1)) / 2;
  
    // Stores sum of pairProductArray
    float res = 0;
  
    for(int i = 0; i < N - 1; i++)
    {
        res += arr[i] *
               suffixSumArray[i + 1];
    }
  
    // Store the mean
    float mean;
  
    // Find mean of pairProductArray
    if (length != 0)
        mean = res / length;
    else
        mean = 0;
  
    // Return the resultant mean
    return mean;
}
 
// Driver Code
public static void main (String[] args)
{
     
    // Given array arr[]
    int arr[] = { 1, 2, 4, 8 };
    int N = arr.length;
  
    // Function call
    System.out.format("%.2f",
                      pairProductMean(arr, N));
}
}
 
// This code is contributed by sanjoy_62

Python3

# Python3 program for the above approach
 
# Function to find the mean of pair
# product array of arr[]
def pairProductMean(arr, N):
     
    # Initializing suffix sum array
    suffixSumArray = [0] * N
    suffixSumArray[N - 1] = arr[N - 1]
 
    # Build suffix sum array
    for i in range(N - 2, -1, -1):
        suffixSumArray[i] = suffixSumArray[i + 1] + arr[i]
 
    # Size of pairProductArray
    length = (N * (N - 1)) // 2
 
    # Stores sum of pairProductArray
    res = 0
 
    for i in range(N - 1):
        res += arr[i] * suffixSumArray[i + 1]
 
    # Store the mean
    mean = 0
 
    # Find mean of pairProductArray
    if (length != 0):
        mean = res / length
    else:
        mean = 0
 
    # Return the resultant mean
    return mean
 
# Driver Code
if __name__ == '__main__':
     
    # Given array arr[]
    arr = [ 1, 2, 4, 8 ]
    N = len(arr)
 
    # Function Call
    print(round(pairProductMean(arr, N), 2))
 
# This code is contributed by mohit kumar 29

C＃

// C# program for the above approach
using System;
  
class GFG{
      
// Function to find the mean of pair
// product array of arr[]
static double pairProductMean(int[] arr, int N)
{
     
    // Initializing suffix sum array
    int[] suffixSumArray = new int[N];
    suffixSumArray[N - 1] = arr[N - 1];
   
    // Build suffix sum array
    for(int i = N - 2; i >= 0; i--)
    {
        suffixSumArray[i] = suffixSumArray[i + 1] +
                                       arr[i];
    }
   
    // Size of pairProductArray
    int length = (N * (N - 1)) / 2;
   
    // Stores sum of pairProductArray
    double res = 0;
   
    for(int i = 0; i < N - 1; i++)
    {
        res += arr[i] *
               suffixSumArray[i + 1];
    }
   
    // Store the mean
    double mean;
   
    // Find mean of pairProductArray
    if (length != 0)
        mean = res / length;
    else
        mean = 0;
   
    // Return the resultant mean
    return mean;
}
  
// Driver code
public static void Main()
{
     
    // Given array arr[]
    int[] arr = { 1, 2, 4, 8 };
    int N = arr.Length;
   
    // Function call
    Console.WriteLine(string.Format("{0:0.00}",
                      pairProductMean(arr, N)));
}
}
  
// This code is contributed by code_hunt

Java脚本

 
// Javascript program for the above approach
 
// Function to find the mean of pair
// product array of arr[]
function pairProductMean(arr, N)
{
    // Initializing suffix sum array
    var suffixSumArray = Array(N);
    suffixSumArray[N - 1] = arr[N - 1];
 
    // Build suffix sum array
    for (var i = N - 2; i >= 0; i--) {
        suffixSumArray[i]
            = suffixSumArray[i + 1]
              + arr[i];
    }
 
    // Size of pairProductArray
    var length = (N * (N - 1)) / 2;
 
    // Stores sum of pairProductArray
    var res = 0;
 
    for (var i = 0; i < N - 1; i++) {
        res += arr[i]
               * suffixSumArray[i + 1];
    }
 
    // Store the mean
    var mean;
 
    // Find mean of pairProductArray
    if (length != 0)
        mean = res / length;
    else
        mean = 0;
 
    // Return the resultant mean
    return mean;
}
 
// Driver Code
// Given array arr[]
var arr = [ 1, 2, 4, 8 ];
var N = arr.length;
// Function Call
document.write( pairProductMean(arr, N).toFixed(2));
 

输出

11.67

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