 Open in App
Not now

# Probability of not getting two consecutive heads together in N tosses of coin

• Difficulty Level : Medium
• Last Updated : 15 Dec, 2022

Given a fair coin that is tossed N times, the task is to determine the probability such that no two heads occur consecutively.

Examples:

Input: N = 2
Output: 0.75
Explanation:
When the coin is tossed 2 times, the possible outcomes are {TH, HT, TT, HH}.
Since in 3 out of 4 outcomes, heads don’t occur together.
Therefore, the required probability is (3/4) or 0.75

Input: N = 3
Output: 0.62
Explanation:
When the coin is tossed 3 times, the possible outcomes are {TTT, HTT, THT, TTH, HHT, HTH, THH, HHH}.
Since in 5 out of 8 outcomes, heads don’t occur together.
Therefore, the required probability is (5/8) or 0.62

Approach: The following observation on the number of favorable outcomes has to be made.

• When N = 1: The possible outcomes are {T, H}. There are two favorable outcomes out of the two.
• When N = 2: The possible outcomes are {TH, HT, TT, HH}. There are three favorable outcomes out of four.
• When N = 3: Similarly, the possible outcomes are {TTT, HTT, THT, TTH, HHT, HTH, THH, HHH}. There are five favorable outcomes out of eight.
• When N = 4: Similarly, the possible outcomes are {TTTT, TTTH, TTHT, THTT, HTTT, TTHH, THTH, HTHT, HHTT, THHT, HTTH, THHH, HTHH, HHTH, HHHT, HHHH}. There are eight favorable outcomes out of sixteen.

Clearly, the number of favorable outcomes follow a Fibonacci series where Fn(1) = 2, Fn(2) = 3 and so on. Therefore, the idea is to implement the Fibonacci sequence in order to find the number of favorable cases. Clearly, the total number of cases is 2N
To calculate the probability, the following formula is used:

P = favorable cases / Total number of cases

Below is the implementation of the above approach:

## C++

 `// C++ implementation to find the ` `// probability of not getting two ` `// consecutive heads together when` `// N coins are tossed` `#include ` `using` `namespace` `std;`   `float` `round(``float` `var,``int` `digit) ` `{ ` `  ``float` `value = (``int``)(var * ` `                 ``pow``(10, digit) + .5); ` `  ``return` `(``float``)value / ` `          ``pow``(10, digit); ` `}`   `// Function to compute the N-th` `// Fibonacci number in the ` `// sequence where a = 2 ` `// and b = 3` `int` `probability(``int` `N)` `{` `  ``// The first two numbers in ` `  ``// the sequence are initialized` `  ``int` `a = 2;` `  ``int` `b = 3;`   `  ``//  Base cases` `  ``if` `(N == 1)` `  ``{` `    ``return` `a;` `  ``}` `  ``else` `if``(N == 2)` `  ``{` `    ``return` `b;` `  ``}` `  ``else` `  ``{` `    ``// Loop to compute the fibonacci ` `    ``// sequence based on the first` `    ``// two initialized numbers` `    ``for``(``int` `i = 3; i <= N; i++)` `    ``{` `      ``int` `c = a + b;` `      ``a = b; ` `      ``b = c;` `    ``}` `    ``return` `b;` `  ``}` `}`   `// Function to find the probability ` `// of not getting two consecutive ` `// heads when N coins are tossed` `float` `operations(``int` `N)` ` ``{` `  ``// Computing the number of` `  ``// favourable cases` `  ``int` `x = probability(N);`   `  ``// Computing the number of ` `  ``// all possible outcomes for ` `  ``// N tosses ` `  ``int` `y = ``pow``(2, N);`   `  ``return` `round((``float``)x / ` `               ``(``float``)y, 2);` `}` ` `  `// Driver code` `int` `main()` `{` `  ``int` `N = 10;` `  ``cout << (operations(N));` `}`   `// Thus code is contributed by Rutvik_56`

## Java

 `// Java implementation to find the ` `// probability of not getting two ` `// consecutive heads together when` `// N coins are tossed` `import` `java.io.*;` `class` `GFG{` `    `  `public` `static` `float` `round(``float` `var, ``int` `digit) ` `{ ` `    ``float` `value = (``int``)(var * ` `                   ``Math.pow(``10``, digit) + .``5``); ` `    ``return` `(``float``)value / ` `           ``(``float``)Math.pow(``10``, digit); ` `}` ` `  `// Function to compute the N-th` `// Fibonacci number in the ` `// sequence where a = 2 ` `// and b = 3` `public` `static` `int` `probability(``int` `N)` `{` `    `  `    ``// The first two numbers in ` `    ``// the sequence are initialized` `    ``int` `a = ``2``;` `    ``int` `b = ``3``;` `    `  `    ``//  Base cases` `    ``if` `(N == ``1``)` `    ``{` `        ``return` `a;` `    ``}` `    ``else` `if` `(N == ``2``)` `    ``{` `        ``return` `b;` `    ``}` `    ``else` `    ``{` `        `  `        ``// Loop to compute the fibonacci ` `        ``// sequence based on the first` `        ``// two initialized numbers` `        ``for``(``int` `i = ``3``; i <= N; i++)` `        ``{` `            ``int` `c = a + b;` `            ``a = b; ` `            ``b = c;` `        ``}` `        ``return` `b;` `    ``}` `}` ` `  `// Function to find the probability ` `// of not getting two consecutive ` `// heads when N coins are tossed` `public` `static` `float` `operations(``int` `N)` `{` `    `  `    ``// Computing the number of` `    ``// favourable cases` `    ``int` `x = probability(N);` `    `  `    ``// Computing the number of ` `    ``// all possible outcomes for ` `    ``// N tosses ` `    ``int` `y = (``int``)Math.pow(``2``, N);` `    `  `    ``return` `round((``float``)x / ` `                 ``(``float``)y, ``2``);` `}`   `// Driver code` `public` `static` `void` `main(String[] args) ` `{` `    ``int` `N = ``10``;` `    `  `    ``System.out.println((operations(N)));` `}` `}`   `// This code is contributed by divyeshrabadiya07`

## Python3

 `# Python3 implementation to find the ` `# probability of not getting two ` `# consecutive heads together when` `# N coins are tossed`     `import` `math`   `# Function to compute the N-th` `# Fibonacci number in the ` `# sequence where a = 2 ` `# and b = 3` `def` `probability(N): `   `    ``# The first two numbers in ` `    ``# the sequence are initialized` `    ``a ``=` `2` `    ``b ``=` `3`   `    ``# Base cases` `    ``if` `N ``=``=` `1``: ` `        ``return` `a` `    ``elif` `N ``=``=` `2``: ` `        ``return` `b` `    ``else``: ` `        `  `        ``# Loop to compute the fibonacci ` `        ``# sequence based on the first` `        ``# two initialized numbers` `        ``for` `i ``in` `range``(``3``, N ``+` `1``): ` `            ``c ``=` `a ``+` `b ` `            ``a ``=` `b ` `            ``b ``=` `c ` `        ``return` `b `   `# Function to find the probability ` `# of not getting two consecutive ` `# heads when N coins are tossed` `def` `operations(N):`   `    ``# Computing the number of` `    ``# favourable cases` `    ``x ``=` `probability (N)`   `    ``# Computing the number of ` `    ``# all possible outcomes for ` `    ``# N tosses ` `    ``y ``=` `math.``pow``(``2``, N)`   `    ``return` `round``(x ``/` `y, ``2``)`   `# Driver code` `if` `__name__ ``=``=` `'__main__'``: `   `    ``N ``=` `10` `    `  `    ``print``(operations(N))` `  `

## C#

 `// C# implementation to find the ` `// probability of not getting two ` `// consecutive heads together when` `// N coins are tossed` `using` `System;`   `class` `GFG{` `    `  `public` `static` `float` `round(``float` `var``, ``int` `digit) ` `{ ` `    ``float` `value = (``int``)(``var` `* ` `                   ``Math.Pow(10, digit) + .5); ` `    ``return` `(``float``)value / ` `           ``(``float``)Math.Pow(10, digit); ` `}` ` `  `// Function to compute the N-th` `// Fibonacci number in the ` `// sequence where a = 2 ` `// and b = 3` `public` `static` `int` `probability(``int` `N)` `{` `    `  `    ``// The first two numbers in ` `    ``// the sequence are initialized` `    ``int` `a = 2;` `    ``int` `b = 3;` `    `  `    ``//  Base cases` `    ``if` `(N == 1)` `    ``{` `        ``return` `a;` `    ``}` `    ``else` `if` `(N == 2)` `    ``{` `        ``return` `b;` `    ``}` `    ``else` `    ``{` `        `  `        ``// Loop to compute the fibonacci ` `        ``// sequence based on the first` `        ``// two initialized numbers` `        ``for``(``int` `i = 3; i <= N; i++)` `        ``{` `            ``int` `c = a + b;` `            ``a = b; ` `            ``b = c;` `        ``}` `        ``return` `b;` `    ``}` `}` ` `  `// Function to find the probability ` `// of not getting two consecutive ` `// heads when N coins are tossed` `public` `static` `float` `operations(``int` `N)` `{` `    `  `    ``// Computing the number of` `    ``// favourable cases` `    ``int` `x = probability(N);` `    `  `    ``// Computing the number of ` `    ``// all possible outcomes for ` `    ``// N tosses ` `    ``int` `y = (``int``)Math.Pow(2, N);` `    `  `    ``return` `round((``float``)x / ` `                 ``(``float``)y, 2);` `}`   `// Driver code` `public` `static` `void` `Main(``string``[] args) ` `{` `    ``int` `N = 10;` `    `  `    ``Console.WriteLine((operations(N)));` `}` `}`   `// This code is contributed by chitranayal`

## Javascript

 ``

Output:

`0.14`

Time Complexity: O(N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Related Articles