二项式随机变量-yiteyi-C++库

在这篇文章中，我们将讨论二项式随机变量。 先决条件： 随机变量一种特殊类型的 离散的 统计特定事件在固定次数的尝试或试验中发生频率的随机变量。对于二项式随机变量，必须满足以下所有条件：

null

试验次数固定（样本量固定）。
在每次试验中，感兴趣的事件要么发生，要么不发生。
在每次试验中发生（或不发生）的概率是相同的。
审判是相互独立的。

数学符号

n = number of trials
p = probability of success in each trial
k = number of success in n trials

现在我们试图找出k在n次试验中成功的概率。在这里，每个试验的成功概率与其他试验无关。因此，我们首先选择k个试验，其中会有一个成功，其余的n-k试验将有一个失败。实现这一点的方法有很多

图片[1]-二项式随机变量-yiteyi-C++库

由于所有n个事件都是独立的，因此n个试验中k个成功的概率等于每个试验的概率乘积。这里是k成功和n-k失败，所以每种方法实现k成功和n-k失败的概率是

图片[2]-二项式随机变量-yiteyi-C++库

因此，最终的概率是

(number of ways to achieve k success
 and n-k failures)
 *
(probability for each way to achieve k
 success and n-k failure)

然后，二项式随机变量概率由下式给出：

图片[3]-二项式随机变量-yiteyi-C++库

设X为二项随机变量，试验次数为n，每次试验的成功概率为p。预期成功次数由以下公式给出：

E[X] = np

成功次数的方差由

Var[X] = np(1-p)

例1 考虑随机实验，其中偏置硬币（概率＝1/3）被抛掷10次。找出出现头部的概率为5。解决方案：

Let X be binomial random variable 
with n = 10 and p = 1/3
P(X=5) = ?

图片[3]-二项式随机变量-yiteyi-C++库

图片[5]-二项式随机变量-yiteyi-C++库

下面是同样的实现

C++

                         // C++ program to compute Binomial Probability                       
                         #include <iostream>                       
                         #include <cmath>                       
                         using                                     namespace                                     std;                       
                                   
                         // function to calculate nCr i.e., number of                       
                         // ways to choose r out of n objects                       
                         int                                     nCr(                                     int                                     n,                                     int                                     r)                       
                         {                       
                                                 // Since nCr is same as nC(n-r)                       
                                                 // To decrease number of iterations                       
                                                 if                                     (r > n / 2)                       
                                                 r = n - r;                       
                                   
                                                 int                                     answer = 1;                       
                                                 for                                     (                                     int                                     i = 1; i <= r; i++) {                       
                                                 answer *= (n - r + i);                       
                                                 answer /= i;                       
                                                 }                       
                                   
                                                 return                                     answer;                       
                         }                       
                                   
                         // function to calculate binomial r.v. probability                       
                         float                                     binomialProbability(                                     int                                     n,                                     int                                     k,                                     float                                     p)                       
                         {                       
                                                 return                                     nCr(n, k) *                                     pow                                     (p, k) *                       
                                                 pow                                     (1 - p, n - k);                       
                         }                       
                                   
                         // Driver code                       
                         int                                     main()                       
                         {                       
                                   
                                                 int                                     n = 10;                       
                                                 int                                     k = 5;                       
                                                 float                                     p = 1.0 / 3;                       
                                   
                                                 float                                     probability = binomialProbability(n, k, p);                       
                                   
                                                 cout <<                                     "Probability of "                                     << k;                       
                                                 cout <<                                     " heads when a coin is tossed "                                     << n;                       
                                                 cout <<                                     " times where probability of each head is "                                     << p << endl;                       
                                                 cout <<                                     " is = "                                     << probability << endl;                       
                         }                       

JAVA

                         // Java program to compute Binomial Probability                       
                                   
                         import                                     java.util.*;                       
                                   
                         class                                     GFG                       
                         {                       
                                                 // function to calculate nCr i.e., number of                       
                                                 // ways to choose r out of n objects                       
                                                 static                                     int                                     nCr(                                     int                                     n,                                     int                                     r)                       
                                                 {                       
                                                 // Since nCr is same as nC(n-r)                       
                                                 // To decrease number of iterations                       
                                                 if                                     (r > n /                                     2                                     )                       
                                                 r = n - r;                       
                                   
                                                 int                                     answer =                                     1                                     ;                       
                                                 for                                     (                                     int                                     i =                                     1                                     ; i <= r; i++) {                       
                                                 answer *= (n - r + i);                       
                                                 answer /= i;                       
                                                 }                       
                                   
                                                 return                                     answer;                       
                                                 }                       
                                   
                                                 // function to calculate binomial r.v. probability                       
                                                 static                                     float                                     binomialProbability(                                     int                                     n,                                     int                                     k,                                     float                                     p)                       
                                                 {                       
                                                 return                                     nCr(n, k) * (                                     float                                     )Math.pow(p, k) *                       
                                                 (                                     float                                     )Math.pow(                                     1                                     - p, n - k);                       
                                                 }                       
                                   
                                                 // Driver code                       
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                                 int                                     n =                                     10                                     ;                       
                                                 int                                     k =                                     5                                     ;                       
                                                 float                                     p = (                                     float                                     )                                     1.0                                     /                                     3                                     ;                       
                                   
                                                 float                                     probability = binomialProbability(n, k, p);                       
                                   
                                                 System.out.print(                                     "Probability of "                                     +k);                       
                                                 System.out.print(                                     " heads when a coin is tossed "                                     +n);                       
                                                 System.out.println(                                     " times where probability of each head is "                                     +p);                       
                                                 System.out.println(                                     " is = "                                     + probability );                       
                                                 }                       
                         }                       
                                   
                         /* This code is contributed by Mr. Somesh Awasthi */                       

Python3

                         # Python3 program to compute Binomial                       
                         # Probability                       
                                   
                         # function to calculate nCr i.e.,                       
                         # number of ways to choose r out                       
                         # of n objects                       
                         def                                     nCr(n, r):                       
                                   
                                                 # Since nCr is same as nC(n-r)                       
                                                 # To decrease number of iterations                       
                                                 if                                     (r > n                                     /                                     2                                     ):                       
                                                 r                                     =                                     n                                     -                                     r;                       
                                   
                                                 answer                                     =                                     1                                     ;                       
                                                 for                                     i                                     in                                     range                                     (                                     1                                     , r                                     +                                     1                                     ):                       
                                                 answer                                     *                                     =                                     (n                                     -                                     r                                     +                                     i);                       
                                                 answer                                     /                                     =                                     i;                       
                                   
                                                 return                                     answer;                       
                                   
                         # function to calculate binomial r.v.                       
                         # probability                       
                         def                                     binomialProbability(n, k, p):                       
                                   
                                                 return                                     (nCr(n, k)                                     *                                     pow                                     (p, k)                                     *                       
                                                 pow                                     (                                     1                                     -                                     p, n                                     -                                     k));                       
                                   
                         # Driver code                       
                         n                                     =                                     10                                     ;                       
                         k                                     =                                     5                                     ;                       
                         p                                     =                                     1.0                                     /                                     3                                     ;                       
                                   
                         probability                                     =                                     binomialProbability(n, k, p);                       
                                   
                         print                                     (                                     "Probability of"                                     , k,                       
                                                 "heads when a coin is tossed"                                     , end                                     =                                     " "                                     );                       
                         print                                     (n,                                     "times where probability of each head is"                                     ,                       
                                                 round                                     (p,                                     6                                     ));                       
                         print                                     (                                     "is = "                                     ,                                     round                                     (probability,                                     6                                     ));                       
                                   
                         # This code is contributed by mits                       

C#

                         // C# program to compute Binomial                       
                         // Probability.                       
                         using                                     System;                       
                                   
                         class                                     GFG {                       
                                   
                                                 // function to calculate nCr                       
                                                 // i.e., number of ways to                       
                                                 // choose r out of n objects                       
                                                 static                                     int                                     nCr(                                     int                                     n,                                     int                                     r)                       
                                                 {                       
                                   
                                                 // Since nCr is same as                       
                                                 // nC(n-r) To decrease                       
                                                 // number of iterations                       
                                                 if                                     (r > n / 2)                       
                                                 r = n - r;                       
                                   
                                                 int                                     answer = 1;                       
                                                 for                                     (                                     int                                     i = 1; i <= r; i++)                       
                                                 {                       
                                                 answer *= (n - r + i);                       
                                                 answer /= i;                       
                                                 }                       
                                   
                                                 return                                     answer;                       
                                                 }                       
                                   
                                                 // function to calculate binomial                       
                                                 // r.v. probability                       
                                                 static                                     float                                     binomialProbability(                       
                                                 int                                     n,                                     int                                     k,                                     float                                     p)                       
                                                 {                       
                                                 return                                     nCr(n, k) *                       
                                                 (                                     float                                     )Math.Pow(p, k)                       
                                                 * (                                     float                                     )Math.Pow(1 - p,                       
                                                 n - k);                       
                                                 }                       
                                   
                                                 // Driver code                       
                                                 public                                     static                                     void                                     Main()                       
                                                 {                       
                                                 int                                     n = 10;                       
                                                 int                                     k = 5;                       
                                                 float                                     p = (                                     float                                     )1.0 / 3;                       
                                   
                                                 float                                     probability =                       
                                                 binomialProbability(n, k, p);                       
                                   
                                                 Console.Write(                                     "Probability of "                       
                                                 + k);                       
                                                 Console.Write(                                     " heads when a coin "                       
                                                 +                                     "is tossed "                                     + n);                       
                                                 Console.Write(                                     " times where "                       
                                                 +                                     "probability of each head is "                       
                                                 + p);                       
                                                 Console.Write(                                     " is = "                       
                                                 + probability );                       
                                                 }                       
                         }                       
                                   
                         // This code is contributed by nitin mittal.                       

PHP

                         <?php                       
                         // php program to compute Binomial                       
                         // Probability                       
                                   
                         // function to calculate nCr i.e.,                       
                         // number of ways to choose r out                       
                         // of n objects                       
                         function                                     nCr(                                     $n                                     ,                                     $r                                     )                       
                         {                       
                                   
                                                 // Since nCr is same as nC(n-r)                       
                                                 // To decrease number of iterations                       
                                                 if                                     (                                     $r                                     >                                     $n                                     / 2)                       
                                                 $r                                     =                                     $n                                     -                                     $r                                     ;                       
                                   
                                                 $answer                                     = 1;                       
                                                 for                                     (                                     $i                                     = 1;                                     $i                                     <=                                     $r                                     ;                                     $i                                     ++) {                       
                                                 $answer                                     *= (                                     $n                                     -                                     $r                                     +                                     $i                                     );                       
                                                 $answer                                     /=                                     $i                                     ;                       
                                                 }                       
                                   
                                                 return                                     $answer                                     ;                       
                         }                       
                                   
                         // function to calculate binomial r.v.                       
                         // probability                       
                         function                                     binomialProbability(                                     $n                                     ,                                     $k                                     ,                                     $p                                     )                       
                         {                       
                                                 return                                     nCr(                                     $n                                     ,                                     $k                                     ) * pow(                                     $p                                     ,                                     $k                                     ) *                       
                                                 pow(1 -                                     $p                                     ,                                     $n                                     -                                     $k                                     );                       
                         }                       
                                   
                         // Driver code                       
                                                 $n                                     = 10;                       
                                                 $k                                     = 5;                       
                                                 $p                                     = 1.0 / 3;                       
                                   
                                                 $probability                                     =                       
                                                 binomialProbability(                                     $n                                     ,                                     $k                                     ,                                     $p                                     );                       
                                   
                                                 echo                                     "Probability of "                                     .                                     $k                                     ;                       
                                                 echo                                     " heads when a coin is tossed "                       
                                                 .                                     $n                                     ;                       
                                                 echo                                     " times where probability of "                       
                                                 .                                     "each head is "                                     .                                     $p                                     ;                       
                                                 echo                                     " is = "                                     .                                     $probability                                     ;                       
                                   
                         // This code is contributed by nitin mittal.                       
                         ?>                       

Javascript

                         <script>                       
                                   
                         // Javascript program to compute Binomial Probability                       
                                   
                                                 // function to calculate nCr i.e., number of                       
                                                 // ways to choose r out of n objects                       
                                                 function                                     nCr(n, r)                       
                                                 {                       
                                                 // Since nCr is same as nC(n-r)                       
                                                 // To decrease number of iterations                       
                                                 if                                     (r > n / 2)                       
                                                 r = n - r;                       
                                   
                                                 let answer = 1;                       
                                                 for                                     (let i = 1; i <= r; i++) {                       
                                                 answer *= (n - r + i);                       
                                                 answer /= i;                       
                                                 }                       
                                   
                                                 return                                     answer;                       
                                                 }                       
                                   
                                                 // function to calculate binomial r.v. probability                       
                                                 function                                     binomialProbability(n, k, p)                       
                                                 {                       
                                                 return                                     nCr(n, k) * Math.pow(p, k) *                       
                                                 Math.pow(1 - p, n - k);                       
                                                 }                       
                                   
                         // driver program                       
                                                 let n = 10;                       
                                                 let k = 5;                       
                                                 let p = 1.0 / 3;                       
                                   
                                                 let probability = binomialProbability(n, k, p);                       
                                   
                                                 document.write(                                     "Probability of "                                     +k);                       
                                                 document.write(                                     " heads when a coin is tossed "                                     +n);                       
                                                 document.write(                                     " times where probability of each head is "                                     +p);                       
                                                 document.write(                                     " is = "                                     + probability );                       
                                   
                                                 // This code is contributed by code_hunt.                       
                         </script>                       

输出：

Probability of 5 heads when a coin is tossed 10 times where probability of each head is 0.333333
 is = 0.136565

参考 : stat200 本文由 普拉提克·切哈杰 .如果你喜欢GeekSforgek，并想贡献自己的力量，你也可以使用写极客。组织或者把你的文章寄去评论-team@geeksforgeeks.org.看到你的文章出现在Geeksforgeks主页上，并帮助其他极客。如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

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

THE END

技术文章