数的调和平均值程序-yiteyi-C++库

给定一个元素数组，求数的调和平均值。例如：

null

Input : arr[] = {2.0, 1.0}Output : 1.3333Harmonic mean = 2/(1/2.0 + 1/1.0)             = (2 * 2)/3             = 1.333Input : arr[] = {13.5, 14.5, 14.8, 15.2, 16.1}Output : 14.7707

当需要平均费率时，使用调和平均值，以下是公式。 n个数x的调和平均 _1. 十、 _2. , 十、 _3. , . . ., 十、 _N 可以这样写。调和平均值=n / （（1/x） _1. )+（1/x） _2. )+（1/x） _3. ) + . . . + （1/x _N ))

下面是调和平均数的实现。

C++

                         // CPP program to find harmonic mean of numbers.                       
                         #include <bits/stdc++.h>                       
                         using                                     namespace                                     std;                       
           
                         // Function that returns harmonic mean.                       
                         float                                     harmonicMean(                                     float                                     arr[],                                     int                                     n)                       
                         {                       
                                                 // Declare sum variables and initialize                       
                                                 // with zero.                       
                                                 float                                     sum = 0;                       
                                                 for                                     (                                     int                                     i = 0; i < n; i++)                       
                                                 sum = sum + (                                     float                                     )1 / arr[i];                       
           
                                                 return                                     (                                     float                                     )n/sum;                       
                         }                       
           
                         // Driver code                       
                         int                                     main()                       
                         {                       
                                                 float                                     arr[] = { 13.5, 14.5, 14.8, 15.2, 16.1 };                       
                                                 int                                     n =                                     sizeof                                     (arr) /                                     sizeof                                     (arr[0]);                       
                                                 cout << harmonicMean(arr, n);                       
                                                 return                                     0;                       
                         }                       

JAVA

                         // JAVA program to find harmonic                       
                         // mean of numbers.                       
                         import                                     java.io.*;                       
           
                         class                                     GFG {                       
                                   
                                                 // Function that returns harmonic mean.                       
                                                 static                                     float                                     harmonicMean(                                     float                                     arr[],                                     int                                     n)                       
                                                 {                       
                                                 // Declare sum variables and                       
                                                 // initialize with zero                       
                                                 float                                     sum =                                     0                                     ;                       
                                                 for                                     (                                     int                                     i =                                     0                                     ; i < n; i++)                       
                                                 sum = sum + (                                     float                                     )                                     1                                     / arr[i];                       
                                   
                                                 return                                     (                                     float                                     )n/sum;                       
                                                 }                       
                                   
                                                 // Driver code                       
                                                 public                                     static                                     void                                     main(String args[])                       
                                                 {                       
                                                 float                                     arr[]= {                                     13                                     .5f,                                     14                                     .5f,                                     14                                     .8f,                       
                                                 15                                     .2f,                                     16                                     .1f };                       
                                                 int                                     n = arr.length;                       
                                                 System.out.println(harmonicMean(arr, n));                       
                                                 }                       
                         }                       
           
                         /*This code is contributed by Nikita Tiwari.*/                       

Python3

                         # Python 3 program to find harmonic                       
                         # mean of numbers.                       
           
                         # Function that returns harmonic mean.                       
                         def                                     harmonicMean(arr, n) :                       
                                   
                                                 # Declare sum variables and                       
                                                 # initialize with zero.                       
                                                 sm                                     =                                     0                       
                                                 for                                     i                                     in                                     range                                     (                                     0                                     , n) :                       
                                                 sm                                     =                                     sm                                     +                                     (                                     1                                     )                                     /                                     arr[i];                       
                                   
                                                 return                                     n                                     /                                     sm                       
           
           
                         # Driver code                       
                         arr                                     =                                     [                                     13.5                                     ,                                     14.5                                     ,                                     14.8                                     ,                                     15.2                                     ,                                     16.1                                     ];                       
                         n                                     =                                     len                                     (arr)                       
                         print                                     (harmonicMean(arr, n))                       
           
                         # This code is contributed by Nikita Tiwari.                       

C#

                         // C# program to find harmonic                       
                         // mean of numbers.                       
                         using                                     System;                       
           
                         class                                     GFG {                       
           
                                                 // Function that returns harmonic mean.                       
                                                 static                                     float                                     harmonicMean(                                     float                                     [] arr,                                     int                                     n)                       
                                                 {                       
                                                 // Declare sum variables and                       
                                                 // initialize with zero                       
                                                 float                                     sum = 0;                       
                                                 for                                     (                                     int                                     i = 0; i < n; i++)                       
                                                 sum = sum + (                                     float                                     )1 / arr[i];                       
           
                                                 return                                     (                                     float                                     )n / sum;                       
                                                 }                       
           
                                                 // Driver code                       
                                                 public                                     static                                     void                                     Main()                       
                                                 {                       
                                                 float                                     [] arr = { 13.5f, 14.5f, 14.8f,                       
                                                 15.2f, 16.1f };                       
                                                 int                                     n = arr.Length;                       
                                                 Console.WriteLine(harmonicMean(arr, n));                       
                                                 }                       
                         }                       
           
                         /*This code is contributed by vt_m.*/                       

PHP

                         <?php                       
                         // PHP program to find                       
                         // harmonic mean of numbers.                       
           
                         // Function that returns                       
                         // harmonic mean.                       
                         function                                     harmonicMean(                                     $arr                                     ,                                     $n                                     )                       
                         {                       
                                   
                                                 // Declare sum variables and                       
                                                 // initialize with zero                       
                                                 $sum                                     = 0;                       
                                                 for                                     (                                     $i                                     = 0;                                     $i                                     <                                     $n                                     ;                                     $i                                     ++)                       
                                                 $sum                                     =                                     $sum                                     + (float)                       
                                                 (1 /                                     $arr                                     [                                     $i                                     ]);                       
           
                                                 return                                     (float)(                                     $n                                     /                                     $sum                                     );                       
                         }                       
           
                         // Driver code                       
                         $arr                                     =                                     array                                     (13.5, 14.5, 14.8, 15.2, 16.1);                       
                         $n                                     = sizeof(                                     $arr                                     );                       
                         echo                                     (harmonicMean(                                     $arr                                     ,                                     $n                                     ));                       
           
                         // This code is contributed by Ajit.                       
                         ?>                       

Javascript

                         <script>                       
           
                         // Javascript program to find harmonic mean of numbers.                       
           
                         // Function that returns harmonic mean.                       
                         function                                     harmonicMean(arr, n)                       
                         {                       
                                                 // Declare sum variables and initialize                       
                                                 // with zero.                       
                                                 let sum = 0;                       
                                                 for                                     (let i = 0; i < n; i++)                       
                                                 sum = sum + (1 / arr[i]);                       
           
                                                 return                                     n/sum;                       
                         }                       
           
                         // Driver code                       
           
                         let arr = [ 13.5, 14.5, 14.8, 15.2, 16.1 ];                       
                         let n = arr.length;                       
                         document.write(harmonicMean(arr, n));                       
           
                         </script>                       

输出：

14.7707

如果给我们元素和它们的频率呢？ 如果给我们n个数，每个数都有一定的频率，那么我们只需使用公式调和平均值=（频率和）/（f _1. /x _1. )+（f） _2. /x _2. )+（f） _3. /x _3. ) + . . . + （f） _N /x _N )) f在哪里 _1. F _2. F _3. , . . ., F _N 是元素和x的频率 _1. , _2. 十、 _3. , . . ., 十、 _N 是数组的元素。频率和=f _1. +f _2. +f _3. , . . ., F _N 例如：

Input : num[] = {13, 14, 15, 16, 17}        freq[] = {2, 5, 13, 7, 3}Output : 15.0631

C++

                         // C++ program to find harmonic mean.                       
                         #include <bits/stdc++.h>                       
                         using                                     namespace                                     std;                       
                         // Function that returns harmonic mean.                       
                         float                                     harmonicMean(                                     int                                     arr[],                                     int                                     freq[],                                     int                                     n)                       
                         {                       
                                                 float                                     sum = 0, frequency_sum = 0;                       
                                                 for                                     (                                     int                                     i = 0; i < n; i++) {                       
                                                 sum = sum + (                                     float                                     )freq[i] / arr[i];                       
                                                 frequency_sum  = frequency_sum  + freq[i];                       
                                                 }                       
                                                 return                                     frequency_sum / sum;                       
                         }                       
           
                         // Driver code                       
                         int                                     main()                       
                         {                       
                                                 int                                     num[] = { 13, 14, 15, 16, 17 };                       
                                                 int                                     freq[] = { 2, 5, 13, 7, 3 };                       
                                                 int                                     n =                                     sizeof                                     (num) /                                     sizeof                                     (num[0]);                       
                                                 cout << harmonicMean(num, freq, n);                       
                                                 return                                     0;                       
                         }                       

JAVA

                         // JAVA program to find harmonic mean.                       
           
                         class                                     GFG {                       
                                   
                                                 // Function that returns harmonic mean.                       
                                                 static                                     float                                     harmonicMean(                                     int                                     arr[],                                     int                                     freq[],                       
                                                 int                                     n)                       
                                                 {                       
                                                 float                                     sum =                                     0                                     , frequency_sum =                                     0                                     ;                       
                                                 for                                     (                                     int                                     i =                                     0                                     ; i < n; i++) {                       
                                                 sum = sum + (                                     float                                     )freq[i] / arr[i];                       
                                                 frequency_sum  = frequency_sum  + freq[i];                       
                                                 }                       
                                                 return                                     (frequency_sum / sum);                       
                                                 }                       
                                   
                                                 // Driver code                       
                                                 public                                     static                                     void                                     main(String args[])                       
                                                 {                       
                                                 int                                     num[] = {                                     13                                     ,                                     14                                     ,                                     15                                     ,                                     16                                     ,                                     17                                     };                       
                                                 int                                     freq[] = {                                     2                                     ,                                     5                                     ,                                     13                                     ,                                     7                                     ,                                     3                                     };                       
                                                 int                                     n = num.length;                       
                                                 System.out.println(harmonicMean(num, freq, n));                       
                                                 }                       
                         }                       
           
                         /*This code is contributed by Nikita Tiwari.*/                       

Python3

                         # Python 3 program to find harmonic mean.                       
           
                         # Function that returns harmonic mean.                       
                         def                                     harmonicMean(arr, freq, n) :                       
                                                 sm                                     =                                     0                       
                                                 frequency_sum                                     =                                     0                       
                                                 for                                     i                                     in                                     range                                     (                                     0                                     ,n) :                       
                                                 sm                                     =                                     sm                                     +                                     freq[i]                                     /                                     arr[i]                       
                                                 frequency_sum                                     =                                     frequency_sum                                     +                                     freq[i]                       
                                   
                                                 return                                     (                                     round                                     (frequency_sum                                     /                                     sm,                                     4                                     ))                       
           
           
                         # Driver code                       
                         num                                     =                                     [                                     13                                     ,                                     14                                     ,                                     15                                     ,                                     16                                     ,                                     17                                     ]                       
                         freq                                     =                                     [                                     2                                     ,                                     5                                     ,                                     13                                     ,                                     7                                     ,                                     3                                     ]                       
                         n                                     =                                     len                                     (num)                       
                         print                                     (harmonicMean(num, freq, n))                       
           
           
                         # This code is contributed by Nikita Tiwari.                       

C#

                         // C# program to find harmonic mean.                       
                         using                                     System;                       
           
                         class                                     GFG {                       
           
                                                 // Function that returns harmonic mean.                       
                                                 static                                     float                                     harmonicMean(                                     int                                     [] arr,                                     int                                     [] freq,                       
                                                 int                                     n)                       
                                                 {                       
                                                 float                                     sum = 0, frequency_sum = 0;                       
                                                 for                                     (                                     int                                     i = 0; i < n; i++) {                       
                                                 sum = sum + (                                     float                                     )freq[i] / arr[i];                       
                                                 frequency_sum = frequency_sum + freq[i];                       
                                                 }                       
                                                 return                                     (frequency_sum / sum);                       
                                                 }                       
           
                                                 // Driver code                       
                                                 public                                     static                                     void                                     Main()                       
                                                 {                       
                                                 int                                     [] num = { 13, 14, 15, 16, 17 };                       
                                                 int                                     [] freq = { 2, 5, 13, 7, 3 };                       
                                                 int                                     n = num.Length;                       
                                                 Console.WriteLine(harmonicMean(num, freq, n));                       
                                                 }                       
                         }                       
           
                         /*This code is contributed by vt_m.*/                       

PHP

                         <?php                       
                         // PHP program to find                       
                         // harmonic mean.                       
           
                         // Function that returns                       
                         // harmonic mean.                       
                         function                                     harmonicMean(                                     $arr                                     ,                                     $freq                                     ,                                     $n                                     )                       
                         {                       
                                                 $sum                                     = 0;                                     $frequency_sum                                     = 0;                       
                                                 for                                     (                                     $i                                     = 0;                                     $i                                     <                                     $n                                     ;                                     $i                                     ++)                       
                                                 {                       
                                                 $sum                                     =                                     $sum                                     + (float)                       
                                                 (                                     $freq                                     [                                     $i                                     ] /                                     $arr                                     [                                     $i                                     ]);                       
                                                 $frequency_sum                                     =                                     $frequency_sum                                     +                       
                                                 $freq                                     [                                     $i                                     ];                       
                                                 }                       
                                                 return                                     (                                     $frequency_sum                                     /                                     $sum                                     );                       
                         }                       
           
                         // Driver code                       
                         $num                                     =                                     array                                     (13, 14, 15, 16, 17);                       
                         $freq                                     =                                     array                                     (2, 5, 13, 7, 3);                       
                         $n                                     = sizeof(                                     $num                                     );                       
                         echo                                     (harmonicMean(                                     $num                                     ,                                     $freq                                     ,                                     $n                                     ));                       
           
                         // This code is contributed by Ajit.                       
                         ?>                       

Javascript

                         <script>                       
           
                         // Javascript program to find harmonic mean.                       
           
                         // Function that returns harmonic mean.                       
                         function                                     harmonicMean(arr, freq, n)                       
                         {                       
                                                 let sum = 0, frequency_sum = 0;                       
                                                 for                                     (let i = 0; i < n; i++) {                       
                                                 sum = sum + (freq[i] / arr[i]);                       
                                                 frequency_sum  = frequency_sum  + freq[i];                       
                                                 }                       
                                                 return                                     frequency_sum / sum;                       
                         }                       
           
                         // Driver code                       
                         let num = [ 13, 14, 15, 16, 17 ];                       
                         let freq = [ 2, 5, 13, 7, 3 ];                       
                         let n = num.length;                       
                         document.write(harmonicMean(num, freq, n));                       
           
                         </script>                       

输出：

15.0631

数的调和平均 调和平均 在Python中： 简单的Python程序，使用 调和平均 作用

Python3

                         #'harmonic_mean()' new function added in 'Python3.6' onwards.                       
                         #Program calculates Harmonic Mean using harmonic_mean()                       
           
                         #imports Python statistics library                       
                         import                                     statistics                       
                         def                                     harmonic_mean():                       
                                                 list                                     =                                     [                                     13.5                                     ,                                     14.5                                     ,                                     14.8                                     ,                                     15.2                                     ,                                     16.1                                     ]                       
                                                 print                                     (statistics.harmonic_mean(                                     list                                     ))                       
           
                         #Driver code                       
                         harmonic_mean()                       
           
           
                         #This code is contributed by 'Abhishek Agrawal'.                       

Output: 14.770680729373778

本文由 达曼德拉·库马尔 .如果你喜欢GeekSforgek，并想贡献自己的力量，你也可以使用贡献极客。组织或者把你的文章寄到contribute@geeksforgeeks.org.看到你的文章出现在Geeksforgeks主页上，并帮助其他极客。如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

文章版权归作者所有，未经允许请勿转载。

THE END

技术文章