Skip to content
Related Articles

Related Articles

Expected Number of Trials to get N Consecutive Heads

View Discussion
Improve Article
Save Article
  • Difficulty Level : Hard
  • Last Updated : 18 Sep, 2022
View Discussion
Improve Article
Save Article

Given a number N. The task is to find the expected number of times a coin must be flipped to get N heads consecutively.
Example: 
 

Input: N = 2 
Output: 6
Input: N = 5 
Output: 62 
 

 

Approach: 
The key is to observe that if we see a tail between any consecutive N flip, it breaks the streak for continuous heads and we have to start over again for N consecutive head. 
Let the expected number of trial be X to get N consecutive heads. Below are the possible Cases: 
 

  • Case 1: If, in the 1st trial, a tail occurs then it means that we have wasted one trial and we will have to do X more trial to get N consecutive head. The probability of this event is 1/2 and the total number of trial required to get N consecutive head is (X + count of the previous trial wasted).
  • Case 2: If, in the 2nd trial, a tail occurs then it means that we have wasted our all previous trial and we will have to do X more trial to get N consecutive head. The probability of this event is 1/4 and the total number of trials required to get N consecutive flips is (X + count of previous trial wasted).
  • Case 3:If, in the 3rd trial, a tail occurs then it means that we have wasted our all previous trial and we will have to do X more trial to get N. The probability of this event is 1/8 and the total number of trials required to get N consecutive flips is (X + count of the previous trial wasted). This will continue until we get N consecutive heads.
  • Case N: Similarly, if in the Nth trial, a tail occurs, then it means that we have wasted our all previous trial and we will have to do X more trial to get N. The probability of this event is 1/2N and the total number of trials required to get N consecutive flips is (X + count of the previous trial wasted)
     

From the above cases, the summation of all probability gives will gives the count of trials for N consecutive heads. Mathematically: 
 

X = (1/2)*(X+1) + (1/4)*(X+2) + (1/8)*(X+3)+. . .+(1/2N)*(X+N) + (1/2N)*N 
 

Solving the above equation for X. We have: 
 

By opening the above expressions and arranging it we have:
X = X(1/2 + 1/4 + 1/8 + . . . . . . 1/2N) 
    + (1/2 + 2/4 + 3/8 . . . . . . . + N/2N 
    + N/2N)

The first part of the above equations form Geometric Progression and second part of the above equations forms an Arithmetico Geometric Sequence. Solving the above sequences separately we have: 
For Geometric Sequence: 
 

Sum of GP series = 1/2 + 1/4 + 1/8 + . . . . . . 1/2N 
first term(a) is 1/2 
common ratio(r) is 1/2 
last term (nth term) is 1/2N which is also a * rN-1 
Hence sum is given by: 
Sum of GP series = (1/2)*( (1 – (1/2)N)/(1 – 1/2) ) using formula : (a * (1 – rN)) / (1 – r) since r < 1 
Sum of GP series = (1 – (1/2)N
 

For Arithmetico Geometric Sequence
 

Let S = Sum of Arithmetico Geometric Sequence:
=> S = (1/2 + 2/4 + 3/8 + . . . . . . N/2N) …….(1)
Multiplying By 2, we get 
=> 2S = (1 + 2/2 + 3/4 + . . . . . . . + N/2N-1) …….(2)
Subtracting the equation(1) from the equation(2), we get 
=> S = (1/2 + 1/4 + 1/8 + . . . . . . 1/2N-1) – N/2N 
=> S = sum of GP series – N/2N 
=> S = (2 – (1/2)N-1)) – N/2N 
 

Using the sum of the GP series and Arithmetico Geometric Sequence: 
 

=> X = X*(1 – (1/2)N) + (2 – (1/2)N-1) – N/2N + N/2N 
=> X = X*(1 – (1/2)N) + (2 – (1/2)N-1
=> X*((1/2)N) = (2 – (1/2)N-1
=> X = 2N+1 – 2 
 

Now the above formula for X gives the number of trials requires getting N consecutive heads.
Below is the implementation of the above approach:
 

C++




// C++ implementation of the above approach
#include "bits/stdc++.h"
using namespace std;
 
// Driver Code
int main()
{
    int N = 3;
 
    // Formula for number of trails for
    // N consecutive heads
    cout << pow(2, N + 1) - 2;
    return 0;
}

Java




// Java implementation of the above approach
class GFG{
 
// Driver Code
public static void main(String[] args)
{
    int N = 3;
 
    // Formula for number of trails for
    // N consecutive heads
    System.out.print(Math.pow(2, N + 1) - 2);
}
}
 
// This code is contributed
// by shivanisinghss2110

Python3




# Python3 implementation of the above approach
 
# Driver code
if __name__ == '__main__':
     
    N = 3
 
    # Formula for number of trails for
    # N consecutive heads
    print(pow(2, N + 1) - 2)
 
# This code is contributed by mohit kumar 29

C#




// C# implementation of the above approach
using System;
class GFG{
 
// Driver Code
public static void Main()
{
    int N = 3;
 
    // Formula for number of trails for
    // N consecutive heads
    Console.Write(Math.Pow(2, N + 1) - 2);
}
}
 
// This code is contributed
// by Code_Mech

Javascript




<script>
 
// Javascript implementation of the above approach
 
// Driver Code
     
    let N = 3;
   
    // Formula for number of trails for
    // N consecutive heads
    document.write(Math.pow(2, N + 1) - 2);
       
</script>

Output: 

14

 

Time Complexity: O(logn)

Auxiliary Space: O(1)
 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!