在N掷硬币中没有将两个连续的头聚集在一起的可能性

给定一个被抛弃N次的公平硬币，任务是确定没有两个正面连续出现的概率。

例子：

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 

方法：必须对有利结果的数量进行以下观察。

• 当N = 1时，可能的结果为{T，H}。在这两个之中有两个有利的结果。
• 当N = 2时：可能的结果是{TH，HT，TT，HH}。有三个有利的结果了四个。
• 当N = 3时：类似地，可能的结果是{TTT，HTT，THT，TTH，HHT，HTH，THH，HHH}。在八项中有五项有利的结果。
• 当N = 4时：类似地，可能的结果是{TTTT，TTTH，TTHT，THTT，HTTT，TTHH，THTH，HTHT，HHTT，THHT，HTTH，THHH，HTHH，HHTH，HHHT，HHHH}。在16个中有8个有利的结果。

显然，有利结果的数量遵循斐波那契数列，其中Fn(1)= 2，Fn(2)= 3，依此类推。因此，该想法是实施斐波那契数列，以便找到有利案例的数量。显然，案件总数为2 ^N。
要计算概率，请使用以下公式：

P = favorable cases / Total number of cases 

下面是上述方法的实现：

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
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

// javascript implementation to find the
// probability of not getting two
// consecutive heads together when
// N coins are tossed   
function round(vr, digit) {
        var value = parseInt( (vr* Math.pow(10, digit) + .5));
        return  value /  Math.pow(10, digit);
    }
 
    // Function to compute the N-th
    // Fibonacci number in the
    // sequence where a = 2
    // and b = 3
    function probability(N) {
 
        // The first two numbers in
        // the sequence are initialized
        var a = 2;
        var 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 (i = 3; i <= N; i++) {
                var 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
    function operations(N) {
 
        // Computing the number of
        // favourable cases
        var x = probability(N);
 
        // Computing the number of
        // all possible outcomes for
        // N tosses
        var y = parseInt( Math.pow(2, N));
 
        return round(x /  y, 2);
    }
 
    // Driver code
    var N = 10;
    document.write((operations(N)));
     
// This code is contributed by aashish1995

输出：

0.14