# Expected Number of Trials to get N Consecutive Heads

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

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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)

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 `

Output:

```14
```

Time Complexity: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.