# Count possible combinations of pairs with adjacent elements from first N numbers

• Difficulty Level : Medium
• Last Updated : 16 Jun, 2022

Given a number N, the task is to count all possible combinations of pairs formed using adjacent elements.
Note: If an element exists already in a pair, it cannot be picked in the next pair. For example: for {1,2,3}: {1,2} and {2,3} will not be considered as a correct combination.
Examples:

```Input : N = 4
Output : 5
Explanation : If N = 4, the possible combinations are:
{1}, {2}, {3}, {4}
{1, 2}, {3, 4}
{1}, {2, 3}, {4}
{1}, {2}, {3, 4}
{1, 2}, {3}, {4}

Input : N = 5
Output : 8```

Approach : Break the problem into smaller subproblems. If there are N numbers, and there are two cases either a number is alone, or it is in a pair, if a number is alone, find the ways of pairing (n-1) numbers left, or if it is in a pair, find the ways of pairing (n-2) numbers left. If there are just 2 numbers left they can generate 2 combinations either alone or in a pair, and if a single number is left it will be in singleton, so there is just 1 combination.
Below is the implementation of the above approach:

## C++

 `#include ``using` `namespace` `std;``// Function to count the number of ways``int` `ways(``int` `n)``{``    ``// If there is a single number left``    ``// it will form singleton``    ``if` `(n == 1) {``        ``return` `1;``    ``}``    ``// if there are just 2 numbers left,``    ``// they will form a pair``    ``if` `(n == 2) {``        ``return` `2;``    ``}``    ``else` `{``        ``return` `ways(n - 1) + ways(n - 2);``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `n = 5;` `    ``cout << ``"Number of ways = "` `<< ways(n);` `    ``return` `0;``}`

## Java

 `/*package whatever //do not write package name here */``import` `java.io.*;` `class` `GFG``{``    ` `// Function to count the number of ways``static` `int` `ways(``int` `n)``{``    ``// If there is a single number left``    ``// it will form singleton``    ``if` `(n == ``1``)``    ``{``        ``return` `1``;``    ``}``    ` `    ``// if there are just 2 numbers left,``    ``// they will form a pair``    ``if` `(n == ``2``)``    ``{``        ``return` `2``;``    ``}``    ``else``    ``{``        ``return` `ways(n - ``1``) + ways(n - ``2``);``    ``}``}` `// Driver Code``public` `static` `void` `main (String[] args)``{``    ``int` `n = ``5``;``    ` `    ``System.out.println(``"Number of ways = "` `+ ways(n));``}``}`

## Python3

 `# Python3 code implementation of the above program` `# Function to count the number of ways``def` `ways(n) :``    ` `    ``# If there is a single number left``    ``# it will form singleton``    ``if` `(n ``=``=` `1``) :``        ``return` `1``;``    ` `    ``# if there are just 2 numbers left,``    ``# they will form a pair``    ``if` `(n ``=``=` `2``) :``        ``return` `2``;``    ` `    ``else` `:``        ``return` `ways(n ``-` `1``) ``+` `ways(n ``-` `2``);` `# Driver Code``if` `__name__ ``=``=` `"__main__"` `:` `    ``n ``=` `5``;` `    ``print``(``"Number of ways = "``, ways(n));` `# This code is contributed by AnkitRai01`

## C#

 `// C# implementation of the above code``using` `System;` `class` `GFG``{``    ` `// Function to count the number of ways``static` `int` `ways(``int` `n)``{``    ``// If there is a single number left``    ``// it will form singleton``    ``if` `(n == 1)``    ``{``        ``return` `1;``    ``}``    ` `    ``// if there are just 2 numbers left,``    ``// they will form a pair``    ``if` `(n == 2)``    ``{``        ``return` `2;``    ``}``    ``else``    ``{``        ``return` `ways(n - 1) + ways(n - 2);``    ``}``}` `// Driver Code``public` `static` `void` `Main()``{``    ``int` `n = 5;``    ` `    ``Console.WriteLine(``"Number of ways = "` `+ ways(n));``}``}` `// This code is contributed by AnkitRai01`

## Javascript

 ``

Output:

`Number of ways = 8`

Time Complexity: O(2^N)
Auxiliary Space: O(N)

Another Approach:

We can store the computed values in an array and reuse the computed value afterwords which would make the program efficient.

Implementation of the above approach:

## C++

 `// C++ implementation of the above approach` `#include ``using` `namespace` `std;` `// vector to store the computed values``vector<``int``> dp;` `// Function to count the number of ways``int` `ways(``int` `n)``{``    ``// If there is a single number left``    ``// it will form singleton``      ``int``& res = dp[n];``      ` `      ``// return the stored value``      ``// if the value is already computed``      ``if``(res!=-1)``          ``return` `res;``  ` `      ``// base case``    ``if` `(n == 1) {``        ``return` `res=1;``    ``}``  ` `    ``// if there are just 2 numbers left,``    ``// they will form a pair``    ``if` `(n == 2) {``        ``return` `res=2;``    ``}``    ``else` `{``          ` `        ``return` `res = ways(n - 1) + ways(n - 2);``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `n = 5;``    ``dp = vector<``int``>(n + 1,-1);``    ``cout << ``"Number of ways = "` `<< ways(n);` `    ``return` `0;``}`

## Java

 `// Java implementation of the above approach` `class` `GFG {` `    ``// vector to store the computed values``    ``static` `int``[] dp;` `    ``// Function to count the number of ways``    ``static` `int` `ways(``int` `n)``    ``{``        ``// If there is a single number left``        ``// it will form singleton``        ``int` `res = dp[n];` `        ``// return the stored value``        ``// if the value is already computed``        ``if` `(res != -``1``)``            ``return` `res;` `        ``// base case``        ``if` `(n == ``1``) {``            ``return` `res = ``1``;``        ``}` `        ``// if there are just 2 numbers left,``        ``// they will form a pair``        ``if` `(n == ``2``) {``            ``return` `res = ``2``;``        ``}``        ``else` `{``            ``return` `res = ways(n - ``1``) + ways(n - ``2``);``        ``}``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `n = ``10``;``        ``dp = ``new` `int``[n + ``1``];``        ``Arrays.fill(dp, -``1``);``        ``System.out.println(``"Number of ways = "` `+ ways(n));``    ``}``}` `// This code is contributed by jainlovely450`

## Python3

 `# Python3 implementation of the above approach` `# vector to store the computed values``dp``=``[]` `# Function to count the number of ways``def` `ways(n):``    ``# If there is a single number left``    ``# it will form singleton``    ``res ``=` `dp[n]``    ` `    ``# return the stored value``    ``# if the value is already computed``    ``if``(res!``=``-``1``):``        ``return` `res` `    ``# base case``    ``if` `(n ``=``=` `1``) :``        ``res``=``1``        ``return` `res``    ` `  ` `    ``# if there are just 2 numbers left,``    ``# they will form a pair``    ``if` `(n ``=``=` `2``) :``        ``res``=``2``        ``return` `res``    ` `    ``else` `:         ``        ``res ``=` `ways(n ``-` `1``) ``+` `ways(n ``-` `2``)``        ``return` `res``    `   `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``n ``=` `5``    ``dp ``=` `[``-``1``]``*``(n ``+` `1``)``    ``print``(``"Number of ways ="``,ways(n))`

## Javascript

 ``

Output

`Number of ways = 8`

Time Complexity: O(n)

Auxiliary Space: O(n)

My Personal Notes arrow_drop_up