获得 N 个连续头的预期试验次数

给定一个数字N 。任务是找出一枚硬币必须翻转的预期次数才能连续出现N次正面。
例子：

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

编程需要懂一点英语

方法：
关键是要观察，如果我们在任何连续的N 次翻转之间看到尾部，它会打破连续正面的连续性，我们必须重新开始连续N次正面。
让预期的试验次数为X以获得N个连续的正面。以下是可能的情况：

情况 1：如果在第1 次试验中出现尾部，则意味着我们浪费了一次试验，我们将不得不再进行X次试验以获得N个连续的正面。此事件的概率为1/2 ，获得N个连续头所需的试验总数为（X + 前一次试验浪费的次数） 。
情况 2：如果在第2 次试验中出现尾部，则意味着我们已经浪费了之前所有的试验，我们将不得不再进行X次试验以获得N个连续的正面。此事件的概率为1/4 ，获得N次连续翻转所需的试验总数为（X + 先前浪费的试验次数）。
情况 3：如果在第3 次试验中出现尾部，则意味着我们已经浪费了之前所有的试验，我们将不得不再进行X次试验才能得到N 。此事件的概率为1/8 ，获得N次连续翻转所需的试验总数为（X + 浪费的前一次试验次数） 。这将一直持续到我们连续得到N个正面。
案例 N：同理，如果在第N 次试验中出现尾部，则意味着我们已经浪费了之前所有的试验，我们将不得不再做X次试验才能得到N。此事件的概率为1/2 ^N ，获得N次连续翻转所需的试验总数为（X + 浪费的前一次试验次数） 。

从上述案例中，所有概率的总和将给出N 个连续正面的试验次数。数学上：

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

编程需要懂一点英语

求解 X 的上述方程。我们有：

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)

上述等式的第一部分构成几何级数，而上述等式的第二部分构成算术几何数列。分别求解上述序列，我们有：
对于几何序列：

Sum of GP series = 1/2 + 1/4 + 1/8 + . . . . . . 1/2^N
first term(a) is 1/2
common ratio(r) is 1/2
last term (nth term) is 1/2^N which is also a * r^N-1
Hence sum is given by:
Sum of GP series = (1/2)*( (1 – (1/2)^N)/(1 – 1/2) ) using formula : (a * (1 – r^N)) / (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/2^N) …….(1)
Multiplying By 2, we get
=> 2S = (1 + 2/2 + 3/4 + . . . . . . . + N/2^N-1) …….(2)
Subtracting the equation(1) from the equation(2), we get
=> S = (1/2 + 1/4 + 1/8 + . . . . . . 1/2^N-1) – N/2^N
=> S = sum of GP series – N/2^N
=> S = (2 – (1/2)^N-1)) – N/2^N

编程需要懂一点英语

使用 GP 系列和算术几何序列的总和：

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

编程需要懂一点英语

现在X的上述公式给出了需要获得N 个连续正面的试验次数。
下面是上述方法的实现：

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

输出：

时间复杂度： O(1)

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。