使用 STL 查找数组中是否存在两个数字及其 AM 和 HM 的程序

给定一个 Number 数组和两个值A和B ，任务是检查以下条件：

1. 数组中是否存在两个数字。
2. 如果是，则它们的算术平均值和谐波平均值是否也存在于同一数组中。
3. 如果满足所有条件，则打印两个数字的几何平均值。

数字的各个均值可以表示如下：

例子：

Input: arr[] = {1.0, 2.0, 2.5, 3.0, 4.0, 4.5, 5.0, 6.0}, A = 3, B = 6. 
Output : GM = 4.24 
Explanation: 
A = 3, B = 6 are present in the array. 
AM = 4.5, HM = 4 are also present in the array. 
So, GM = 4.24
Input: arr = {1.0, 2.0, 2.5, 3.0, 4.0, 4.5, 5.0, 6.0}, A = 4, B = 6. 
Output: AM and HM not found

方法：

• 这个想法是使用Hashing ，使用它我们可以简单地将数组元素存储在 Hash 容器中，并使用恒定时间O(1)操作来查找和跟踪数字及其均值。最后，如果通过观察简单关系AM * HM = GM ²满足所有条件，则计算几何平均值。
• 上述方法的逐步实现如下：
  1. 定义了一个哈希容器来存储数组元素。
  2. 根据公式计算算术平均值和调和平均值。
  3. 使用简单的条件语句在恒定时间内查找 Hash 容器中的元素。
  4. 如果所有条件都满足，则根据上述关系计算 GM。

下面是上述方法的实现：

C++

// C++ program to check if two numbers
// are present in an array then their
// AM and HM are also present. Finally,
// find the GM of the numbers
#include 
using namespace std;
 
// Function to find the Arithmetic Mean
// of 2 numbers
float ArithmeticMean(float A, float B)
{
    return (A + B) / 2;
}
 
// Function to find the Harmonic Mean
// of 2 numbers
float HarmonicMean(float A, float B)
{
    return (2 * A * B) / (A + B);
}
 
// Following function checks and computes the
// desired results based on the means
void CheckArithmeticHarmonic(float arr[],
                             float A,
                             float B, int N)
{
     
    // Calculate means
    float AM = ArithmeticMean(A, B);
    float HM = HarmonicMean(A, B);
 
    // Hash container (Set) to store elements
    unordered_set Hash;
 
    // Insertion of array elements in the Set
    for (int i = 0; i < N; i++)
    {
        Hash.insert(arr[i]);
    }
 
    // Conditionals to check if numbers
    // are present in array by Hashing
    if (Hash.find(A) != Hash.end()
        && Hash.find(B) != Hash.end()) {
 
        // Conditionals to check if the AM and HM
        // of the numbers are present in array
        if (Hash.find(AM) != Hash.end()
            && Hash.find(HM) != Hash.end()) {
           
            // If all conditions are satisfied,
            // the Geometric Mean is calculated
            cout << "GM = ";
            printf("%0.2f", sqrt(AM * HM));
        }
        else
        {
            // If numbers are found but the
            // respective AM and HM are not
            // found in the array
            cout << "AM and HM not found";
        }
    }
    else
    {
        // If none of the conditions are satisfied
        cout << "Numbers not found";
    }
}
 
int main()
{
   
    float arr[] = {1.0, 2.0, 2.5, 3.0, 4.0,
                   4.5, 5.0, 6.0};
 
    int N = sizeof(arr)/sizeof(arr[0]);
    float A = 3.0;
    float B = 6.0;
    CheckArithmeticHarmonic(arr, A, B, N);
    return 0;
}

Java

// Java program to check if two numbers
// are present in an array then their
// AM and HM are also present. Finally,
// find the GM of the numbers
import java.util.*;
 
class GFG{
     
// Function to find the Arithmetic Mean
// of 2 numbers
static Double ArithmeticMean(Double A, Double B)
{
    return (A + B) / 2;
}
 
// Function to find the Harmonic Mean
// of 2 numbers
static Double HarmonicMean(Double A, Double B)
{
    return (2 * A * B) / (A + B);
}
 
// Following function checks and computes the
// desired results based on the means
static void CheckArithmeticHarmonic(Double arr[],
                                    Double A,
                                    Double B, int N)
{
 
    // Calculate means
    Double AM = ArithmeticMean(A, B);
    Double HM = HarmonicMean(A, B);
     
    // Hash container (HashMap) to store elements
    HashMap Hash = new HashMap();
     
    // Insertion of array elements in the Set
    for(int i = 0; i < N; i++)
    {
        Hash.put(arr[i], 1);
    }
     
    // Conditionals to check if numbers
    // are present in array by Hashing
    if (Hash.get(A) != 0 &&
        Hash.get(B) != 0)
    {
         
        // Conditionals to check if the AM and HM
        // of the numbers are present in array
        if (Hash.get(AM) != 0 &&
            Hash.get(HM) != 0)
        {
             
            // If all conditions are satisfied,
            // the Geometric Mean is calculated
            System.out.print("GM = ");
            System.out.format("%.2f", Math.sqrt(AM * HM));
        }
        else
        {
             
            // If numbers are found but the
            // respective AM and HM are not
            // found in the array
            System.out.print("AM and HM not found");
        }
    }
    else
    {
         
        // If none of the conditions are satisfied
        System.out.print("numbers not found");
    }
}
 
// Driver code
public static void main(String args[])
{
    Double arr[] = { 1.0, 2.0, 2.5, 3.0,
                     4.0, 4.5, 5.0, 6.0};
                      
    int N = (arr.length);
    Double A = 3.0;
    Double B = 6.0;
     
    CheckArithmeticHarmonic(arr, A, B, N);
}
}
 
// This code is contributed by Stream_Cipher

Python3

# Python3 program to check if two numbers
# are present in an array then their
# AM and HM are also present. Finally,
# find the GM of the numbers
from math import sqrt
 
# Function to find the arithmetic mean
# of 2 numbers
def ArithmeticMean(A, B):
    return (A + B) / 2
 
# Function to find the harmonic mean
# of 2 numbers
def HarmonicMean(A, B):
    return (2 * A * B) / (A + B)
 
# Following function checks and computes the
# desired results based on the means
def CheckArithmeticHarmonic(arr, A, B, N):
     
    # Calculate means
    AM = ArithmeticMean(A, B)
    HM = HarmonicMean(A, B)
 
    # Hash container (set) to store elements
    Hash = set()
 
    # Insertion of array elements in the set
    for i in range(N):
        Hash.add(arr[i])
 
    # Conditionals to check if numbers
    # are present in array by Hashing
    if (A in Hash and B in Hash):
         
        # Conditionals to check if the AM and HM
        # of the numbers are present in array
        if (AM in Hash and HM in Hash):
             
            # If all conditions are satisfied,
            # the Geometric Mean is calculated
            print("GM =", round(sqrt(AM * HM), 2))
        else:
             
            # If numbers are found but the
            # respective AM and HM are not
            # found in the array
            print("AM and HM not found")
    else:
         
        # If none of the conditions are satisfied
        print("Numbers not found")
 
# Driver Code
if __name__ == '__main__':
 
    arr = [ 1.0, 2.0, 2.5, 3.0,
            4.0, 4.5, 5.0, 6.0 ]
    N = len(arr)
    A = 3.0
    B = 6.0
     
    CheckArithmeticHarmonic(arr, A, B, N)
 
# This code is contributed by Samarth

C#

// C# program to check if two numbers
// are present in an array then their
// AM and HM are also present. Finally,
// find the GM of the numbers
using System;
using System.Collections.Generic;
 
class GFG{
     
// Function to find the Arithmetic Mean
// of 2 numbers
static Double ArithmeticMean(Double A, Double B)
{
    return (A + B) / 2;
}
 
// Function to find the Harmonic Mean
// of 2 numbers
static Double HarmonicMean(Double A, Double B)
{
    return (2 * A * B) / (A + B);
}
 
// Following function checks and computes the
// desired results based on the means
static void CheckArithmeticHarmonic(Double []arr,
                                    Double A,
                                    Double B, int N)
{
 
    // Calculate means
    Double AM = ArithmeticMean(A, B);
    Double HM = HarmonicMean(A, B);
     
    // Hash container (Set) to store elements
    // HashMap Hash = new HashMap();
    Dictionary Hash = new Dictionary();
     
    // Insertion of array elements in the Set
    for(int i = 0; i < N; i++)
    {
        Hash[arr[i]] = 1;
    }
     
    // Conditionals to check if numbers
    // are present in array by Hashing
    if (Hash.ContainsKey(A) &&
        Hash.ContainsKey(B))
    {
         
        // Conditionals to check if the AM and HM
        // of the numbers are present in array
        if (Hash.ContainsKey(AM) &&
            Hash.ContainsKey(HM))
        {
             
            // If all conditions are satisfied,
            // the Geometric Mean is calculated
            Console.Write("GM = ");
            Console.Write(Math.Round(
                          Math.Sqrt(AM * HM), 2));
        }
        else
        {
             
            // If numbers are found but the
            // respective AM and HM are not
            // found in the array
            Console.WriteLine("AM and HM not found");
        }
    }
    else
    {
         
        // If none of the conditions are satisfied
        Console.WriteLine("numbers not found");
    }
}
 
// Driver code
public static void Main()
{
    Double []arr = { 1.0, 2.0, 2.5, 3.0,
                     4.0, 4.5, 5.0, 6.0 };
 
    int N = (arr.Length);
    Double A = 3.0;
    Double B = 6.0;
     
    CheckArithmeticHarmonic(arr, A, B, N);
}
}
 
// This code is contributed by Stream_Cipher

Javascript

 
// Javascript program to check if two numbers
// are present in an array then their
// AM and HM are also present. Finally,
// find the GM of the numbers
 
// Function to find the Arithmetic Mean
// of 2 numbers
function ArithmeticMean(A, B)
{
    return ((A + B) / 2);
}
   
// Function to find the Harmonic Mean
// of 2 numbers
function HarmonicMean(A, B)
{
    return (2 * A * B) / (A + B);
}
   
// Following function checks and computes the
// desired results based on the means
function CheckArithmeticHarmonic(arr, A, B, N)
{
   
    // Calculate means
    let AM = ArithmeticMean(A, B);
    let HM = HarmonicMean(A, B);
       
    // Hash container (HashMap) to store elements
    let Hash = new Map();
       
    // Insertion of array elements in the Set
    for(let i = 0; i < N; i++)
    {
        Hash.set(arr[i], 1);
    }
       
    // Conditionals to check if numbers
    // are present in array by Hashing
    if (Hash.get(A) != 0 &&
        Hash.get(B) != 0)
    {
           
        // Conditionals to check if the AM and HM
        // of the numbers are present in array
        if (Hash.get(AM) != 0 &&
            Hash.get(HM) != 0)
        {
               
            // If all conditions are satisfied,
            // the Geometric Mean is calculated
            document.write("GM = ");
            document.write(Math.sqrt(AM * HM).toFixed(2));
        }
        else
        {
               
            // If numbers are found but the
            // respective AM and HM are not
            // found in the array
            document.write("AM and HM not found");
        }
    }
    else
    {
           
        // If none of the conditions are satisfied
        document.write("numbers not found");
    }
}
 
// Driver code
     
    let arr = [ 1.0, 2.0, 2.5, 3.0,
                     4.0, 4.5, 5.0, 6.0];
                        
    let N = (arr.length);
    let A = 3.0;
    let B = 6.0;
       
    CheckArithmeticHarmonic(arr, A, B, N);
      
     // This code is contributed by code_hunt.

输出：

GM = 4.24

复杂度分析：
上述程序的总时间复杂度基于用户定义输入处数组元素的初始迭代。与 Set 相关的查找操作都是 O(1) 恒定时间操作。因此，程序的复杂度是O(N) ，其中 N 是数组的大小。

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。