# In how many ways the ball will come back to the first boy after N turns

Four boys are playing a game with a ball. In each turn, the player (who has the ball currently) passes it to a **different** player randomly. Bob always starts the game. The task is to find in how many ways the ball will come back to Bob after **N** passes.**Examples:**

Input:N = 3Output:6

Here are all the possible ways:

Bob -> Boy1 -> Boy2 -> Bob

Bob -> Boy1 -> Boy3 -> Bob

Bob -> Boy2 -> Boy1 -> Bob

Bob -> Boy2 -> Boy3 -> Bob

Bob -> Boy3 -> Boy1 -> Bob

Bob -> Boy3 -> Boy2 -> BobInput:N = 10Output:14763

**Approach:** Let the number of sequences that get back to Bob after **N** passes are **P(N)**. The are two cases, either pass **N – 2** is to Bob or it is not. Note that Bob can’t have the ball at **(N – 1) ^{th}** pass because then he won’t have the ball at the

**N**pass.

^{th}**Case 1:**If pass**N – 2**is to Bob then the pass**N – 1**can be to any of the other 3 boys. Thus, the number of such sequences is**3 * P(N – 2)**.**Case 2:**If pass**N – 2**is not to Bob then pass**N – 1**is to one of the 2 boys other than Bob and the one who got the ball in hand. So, substitute Bob for the receiver of pass**N – 1**, and get a unique**N – 1**sequence. So, the number of such sequences are**2 * P(N – 1)**.

Hence the recurrence relation will be **P(N) = 2 * P(N – 1) + 3 * P(N – 2)** where **P(0) = 1** and **P(1) = 0**.

After solving the recurrence relation, **P(N) = (3 ^{N} + 3 * (-1^{N})) / 4**

Below is the implementation of the above approach:

## C++

`// Function to return the number of` `// sequences that get back to Bob` `#include <bits/stdc++.h>` `using` `namespace` `std;` `int` `numSeq(` `int` `n)` `{` ` ` `return` `(` `pow` `(3, n) + 3 * ` `pow` `(-1, n)) / 4;` `}` `// Driver code` `int` `main()` `{` ` ` `int` `N = 10;` ` ` `printf` `(` `"%d"` `, numSeq(N));` ` ` `return` `0;` `}` `// This code is contributed by Mohit kumar` |

## Java

`// Function to return the number of` `// sequences that get back to Bob` `import` `java.util.*;` `class` `GFG` `{` `static` `int` `numSeq(` `int` `n)` `{` ` ` `return` `(` `int` `) ((Math.pow(` `3` `, n) + ` `3` `*` ` ` `Math.pow(-` `1` `, n)) / ` `4` `);` `}` `// Driver code` `public` `static` `void` `main(String[] args)` `{` ` ` `int` `N = ` `10` `;` ` ` `System.out.printf(` `"%d"` `, numSeq(N));` `}` `}` `// This code is contributed by Rajput-Ji` |

## Python3

`# Function to return the number of` `# sequences that get back to Bob` `def` `numSeq(n):` ` ` `return` `(` `pow` `(` `3` `, n) ` `+` `3` `*` `pow` `(` `-` `1` `, n))` `/` `/` `4` ` ` `# Driver code` `N ` `=` `10` `print` `(numSeq(N))` |

## C#

`// C# implementation of the above approach` `using` `System;` `// Function to return the number of` `// sequences that get back to Bob` `class` `GFG` `{` ` ` `static` `int` `numSeq(` `int` `n)` ` ` `{` ` ` `return` `(` `int` `) ((Math.Pow(3, n) + 3 *` ` ` `Math.Pow(-1, n)) / 4);` ` ` `}` ` ` ` ` `// Driver code` ` ` `public` `static` `void` `Main()` ` ` `{` ` ` `int` `N = 10;` ` ` `Console.WriteLine(numSeq(N));` ` ` `}` `}` `// This code is contributed by AnkitRai01` |

## Javascript

`<script>` `// Function to return the number of` `// sequences that get back to Bob` `function` `numSeq(n)` `{` ` ` `return` `Math.floor((Math.pow(3, n) + 3 * Math.pow(-1, n)) / 4);` `}` `// Driver code` ` ` `let N = 10;` ` ` `document.write(numSeq(N));` `// This code is contributed by Surbhi Tyagi.` `</script>` |

**Output:**

14763

Time Complexity: O(log n)

Auxiliary Space: O(1)