# Count the number of ordered sets not containing consecutive numbers

Given a positive integer N. Count the total number of ordered sets of any size such that consecutive numbers are not present in the set and all numbers are <= N.

Ordered Set: Arrays in which all numbers are distinct, and order of elements is taken into consideration, For e.g. {1, 2, 3} is different from {1, 3, 2}.

Examples:

Input: N = 3
Output:
Explanation:
The ordered sets are:
{1}, {2}, {3}, {1, 3}, {3, 1}
Input: N = 6
Output: 50

Naive Approach:

• We will use Recursion to solve this problem. If we obtain count say C of the ordered set where elements are in ascending/descending order and the set size is S, then total count for this size will

• .We will do this for each ordered set of distinct size.
• Iterate on all ordered set sizes and for each size find the count of ordered sets and multiply by factorial of size ( S! ). At each recursive step, we have two options –
1. Include the current element x and move to the next position with maximum element that can be included now as x – 2.
2. Do not included the current element x and stay at the current position with maximum element that can be included now as x – 1.
• So the recursive relation is :

```countSets(x, pos) = countSets(x-2, pos-1) + countSets(x-1, pos)

```

## C++

 `// C++ program to Count the number of  ` `// ordered sets not containing  ` `// consecutive numbers ` `#include ` `using` `namespace` `std; ` ` `  `// Function to calculate the count ` `// of ordered set for a given size ` `int` `CountSets(``int` `x, ``int` `pos) ` `{ ` `    ``// Base cases ` `    ``if` `(x <= 0) { ` `        ``if` `(pos == 0) ` `            ``return` `1; ` `        ``else` `            ``return` `0; ` `    ``} ` `    ``if` `(pos == 0) ` `        ``return` `1; ` ` `  `    ``int` `answer = CountSets(x - 1, pos) ` `              ``+ CountSets(x - 2, pos - 1); ` `     `  `    ``return` `answer; ` `} ` `// Function returns the count  ` `// of all ordered sets ` `int` `CountOrderedSets(``int` `n) ` `{ ` `    ``// Prestore the factorial value ` `    ``int` `factorial[10000]; ` `    ``factorial[0] = 1; ` ` `  `    ``for` `(``int` `i = 1; i < 10000; i++) ` `        ``factorial[i] = factorial[i - 1] * i; ` ` `  `    ``int` `answer = 0; ` ` `  `    ``// Iterate all ordered set sizes and find  ` `    ``// the count for each one maximum ordered  ` `    ``// set size will be smaller than N as all ` `    ``// elements are distinct and non consecutive ` `    ``for` `(``int` `i = 1; i <= n; i++) { ` ` `  `        ``// Multiply ny size! for all the ` `        ``// arrangements because sets are ordered ` `        ``int` `sets = CountSets(n, i) * factorial[i]; ` `         `  `        ``// Add to total answer ` `        ``answer = answer + sets; ` `    ``} ` `    ``return` `answer; ` `} ` `// Driver code ` `int` `main() ` `{ ` `    ``int` `N = 3; ` ` `  `    ``cout << CountOrderedSets(N); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program to count the number   ` `// of ordered sets not containing  ` `// consecutive numbers ` `class` `GFG{ ` ` `  `// Function to calculate the count ` `// of ordered set for a given size ` `static` `int` `CountSets(``int` `x, ``int` `pos) ` `{ ` `     `  `    ``// Base cases ` `    ``if` `(x <= ``0``) ` `    ``{ ` `        ``if` `(pos == ``0``) ` `            ``return` `1``; ` `        ``else` `            ``return` `0``; ` `    ``} ` `    ``if` `(pos == ``0``) ` `        ``return` `1``; ` ` `  `    ``int` `answer = CountSets(x - ``1``, pos) +  ` `                 ``CountSets(x - ``2``, pos - ``1``); ` `    ``return` `answer; ` `} ` ` `  `// Function returns the count  ` `// of all ordered sets ` `static` `int` `CountOrderedSets(``int` `n) ` `{ ` `     `  `    ``// Prestore the factorial value ` `    ``int` `[]factorial = ``new` `int``[``10000``]; ` `    ``factorial[``0``] = ``1``; ` ` `  `    ``for``(``int` `i = ``1``; i < ``10000``; i++) ` `       ``factorial[i] = factorial[i - ``1``] * i; ` ` `  `    ``int` `answer = ``0``; ` ` `  `    ``// Iterate all ordered set sizes and find  ` `    ``// the count for each one maximum ordered  ` `    ``// set size will be smaller than N as all ` `    ``// elements are distinct and non consecutive ` `    ``for``(``int` `i = ``1``; i <= n; i++)  ` `    ``{ ` `        `  `       ``// Multiply ny size! for all the ` `       ``// arrangements because sets are ordered ` `       ``int` `sets = CountSets(n, i) * factorial[i]; ` `        `  `       ``// Add to total answer ` `       ``answer = answer + sets; ` `    ``} ` `    ``return` `answer; ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``int` `N = ``3``; ` ` `  `    ``System.out.print(CountOrderedSets(N)); ` `} ` `} ` ` `  `// This code is contributed by sapnasingh4991 `

## Python3

 `# Python3 program to count the number of  ` `# ordered sets not containing  ` `# consecutive numbers ` ` `  `# Function to calculate the count ` `# of ordered set for a given size ` `def` `CountSets(x, pos): ` `     `  `    ``# Base cases ` `    ``if` `(x <``=` `0``): ` `        ``if` `(pos ``=``=` `0``): ` `            ``return` `1` `        ``else``: ` `            ``return` `0` `    ``if` `(pos ``=``=` `0``): ` `        ``return` `1` ` `  `    ``answer ``=` `(CountSets(x ``-` `1``, pos) ``+`  `              ``CountSets(x ``-` `2``, pos ``-` `1``)) ` `               `  `    ``return` `answer ` `     `  `# Function returns the count  ` `# of all ordered sets ` `def` `CountOrderedSets(n): ` `     `  `    ``# Prestore the factorial value ` `    ``factorial ``=` `[``1` `for` `i ``in` `range``(``10000``)] ` `    ``factorial[``0``] ``=` `1` ` `  `    ``for` `i ``in` `range``(``1``, ``10000``, ``1``): ` `        ``factorial[i] ``=` `factorial[i ``-` `1``] ``*` `i ` ` `  `    ``answer ``=` `0` ` `  `    ``# Iterate all ordered set sizes and find  ` `    ``# the count for each one maximum ordered  ` `    ``# set size will be smaller than N as all ` `    ``# elements are distinct and non consecutive ` `    ``for` `i ``in` `range``(``1``, n ``+` `1``, ``1``): ` `         `  `        ``# Multiply ny size! for all the ` `        ``# arrangements because sets are ordered ` `        ``sets ``=` `CountSets(n, i) ``*` `factorial[i] ` `         `  `        ``# Add to total answer ` `        ``answer ``=` `answer ``+` `sets ` `         `  `    ``return` `answer ` ` `  `# Driver code ` `if` `__name__ ``=``=` `'__main__'``: ` `     `  `    ``N ``=` `3` `    ``print``(CountOrderedSets(N)) ` ` `  `# This code is contributed by Samarth `

## C#

 `// C# program to count the number  ` `// of ordered sets not containing  ` `// consecutive numbers ` `using` `System; ` `class` `GFG{ ` ` `  `// Function to calculate the count ` `// of ordered set for a given size ` `static` `int` `CountSets(``int` `x, ``int` `pos) ` `{ ` `     `  `    ``// Base cases ` `    ``if` `(x <= 0) ` `    ``{ ` `        ``if` `(pos == 0) ` `            ``return` `1; ` `        ``else` `            ``return` `0; ` `    ``} ` `    ``if` `(pos == 0) ` `        ``return` `1; ` ` `  `    ``int` `answer = CountSets(x - 1, pos) +  ` `                 ``CountSets(x - 2, pos - 1); ` `    ``return` `answer; ` `} ` ` `  `// Function returns the count  ` `// of all ordered sets ` `static` `int` `CountOrderedSets(``int` `n) ` `{ ` `     `  `    ``// Prestore the factorial value ` `    ``int` `[]factorial = ``new` `int``[10000]; ` `    ``factorial[0] = 1; ` ` `  `    ``for``(``int` `i = 1; i < 10000; i++) ` `    ``factorial[i] = factorial[i - 1] * i; ` ` `  `    ``int` `answer = 0; ` ` `  `    ``// Iterate all ordered set sizes and find  ` `    ``// the count for each one maximum ordered  ` `    ``// set size will be smaller than N as all ` `    ``// elements are distinct and non consecutive ` `    ``for``(``int` `i = 1; i <= n; i++)  ` `    ``{ ` `         `  `        ``// Multiply ny size! for all the ` `        ``// arrangements because sets are ordered ` `        ``int` `sets = CountSets(n, i) * factorial[i]; ` `             `  `        ``// Add to total answer ` `        ``answer = answer + sets; ` `    ``} ` `    ``return` `answer; ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``int` `N = 3; ` ` `  `    ``Console.Write(CountOrderedSets(N)); ` `} ` `} ` ` `  `// This code is contributed by sapnasingh4991 `

Output:

```5

```

Time Complexity: O(2N)
Efficient Approach:

• In the recursive approach, we are solving subproblems multiple times, i.e. it follows the Overlapping Subproblems Property in Dynamic Programming. So we can use a memorization table or cache to make the solution efficient.

## C++

 `// C++ program to Count the number  ` `// of ordered sets not containing  ` `// consecutive numbers ` `#include ` `using` `namespace` `std; ` ` `  `// DP table ` `int` `dp[500][500]; ` ` `  `// Function to calculate the count ` `// of ordered set for a given size ` `int` `CountSets(``int` `x, ``int` `pos) ` `{ ` `    ``// Base cases ` `    ``if` `(x <= 0) { ` `        ``if` `(pos == 0) ` `            ``return` `1; ` `        ``else` `            ``return` `0; ` `    ``} ` `    ``if` `(pos == 0) ` `        ``return` `1; ` ` `  `    ``// If subproblem has been  ` `    ``// soved before ` `    ``if` `(dp[x][pos] != -1) ` `        ``return` `dp[x][pos]; ` ` `  `    ``int` `answer = CountSets(x - 1, pos) ` `        ``+ CountSets(x - 2, pos - 1); ` ` `  `    ``// Store and return answer to  ` `    ``// this subproblem ` `    ``return` `dp[x][pos] = answer; ` `} ` ` `  `// Function returns the count  ` `// of all ordered sets ` `int` `CountOrderedSets(``int` `n) ` `{ ` `    ``// Prestore the factorial value ` `    ``int` `factorial[10000]; ` `    ``factorial[0] = 1; ` ` `  `    ``for` `(``int` `i = 1; i < 10000; i++) ` `        ``factorial[i] = factorial[i - 1] * i; ` ` `  `    ``int` `answer = 0; ` ` `  `    ``// Initialise the dp table ` `    ``memset``(dp, -1, ``sizeof``(dp)); ` ` `  `    ``// Iterate all ordered set sizes and find  ` `    ``// the count for each one maximum ordered ` `    ``// set size will be smaller than N as all ` `    ``// elements are distinct and non consecutive. ` `    ``for` `(``int` `i = 1; i <= n; i++) { ` ` `  `        ``// Multiply ny size! for all the  ` `        ``// arrangements because sets  ` `        ``// are ordered. ` `        ``int` `sets = CountSets(n, i) * factorial[i]; ` `         `  `        ``// Add to total answer ` `        ``answer = answer + sets; ` `    ``} ` `    ``return` `answer; ` `} ` `// Driver code ` `int` `main() ` `{ ` `    ``int` `N = 3; ` ` `  `    ``cout << CountOrderedSets(N); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program to count the number  ` `// of ordered sets not containing  ` `// consecutive numbers ` `import` `java.util.*; ` ` `  `class` `GFG{ ` ` `  `// DP table ` `static` `int` `[][]dp = ``new` `int``[``500``][``500``]; ` ` `  `// Function to calculate the count ` `// of ordered set for a given size ` `static` `int` `CountSets(``int` `x, ``int` `pos) ` `{ ` `     `  `    ``// Base cases ` `    ``if` `(x <= ``0``)  ` `    ``{ ` `        ``if` `(pos == ``0``) ` `            ``return` `1``; ` `        ``else` `            ``return` `0``; ` `    ``} ` `    ``if` `(pos == ``0``) ` `        ``return` `1``; ` ` `  `    ``// If subproblem has been  ` `    ``// soved before ` `    ``if` `(dp[x][pos] != -``1``) ` `        ``return` `dp[x][pos]; ` ` `  `    ``int` `answer = CountSets(x - ``1``, pos) +  ` `                 ``CountSets(x - ``2``, pos - ``1``); ` ` `  `    ``// Store and return answer to  ` `    ``// this subproblem ` `    ``return` `dp[x][pos] = answer; ` `} ` ` `  `// Function returns the count  ` `// of all ordered sets ` `static` `int` `CountOrderedSets(``int` `n) ` `{ ` `     `  `    ``// Prestore the factorial value ` `    ``int` `[]factorial = ``new` `int``[``10000``]; ` `    ``factorial[``0``] = ``1``; ` ` `  `    ``for``(``int` `i = ``1``; i < ``10000``; i++) ` `        ``factorial[i] = factorial[i - ``1``] * i; ` ` `  `    ``int` `answer = ``0``; ` ` `  `    ``// Initialise the dp table ` `    ``for``(``int` `i = ``0``; i < ``500``; i++) ` `    ``{ ` `        ``for``(``int` `j = ``0``; j < ``500``; j++) ` `        ``{ ` `            ``dp[i][j] = -``1``; ` `        ``} ` `    ``} ` ` `  `    ``// Iterate all ordered set sizes and find  ` `    ``// the count for each one maximum ordered ` `    ``// set size will be smaller than N as all ` `    ``// elements are distinct and non consecutive. ` `    ``for``(``int` `i = ``1``; i <= n; i++) ` `    ``{ ` ` `  `        ``// Multiply ny size! for all the  ` `        ``// arrangements because sets  ` `        ``// are ordered. ` `        ``int` `sets = CountSets(n, i) * factorial[i]; ` `         `  `        ``// Add to total answer ` `        ``answer = answer + sets; ` `    ``} ` `    ``return` `answer; ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``int` `N = ``3``; ` ` `  `    ``System.out.print(CountOrderedSets(N)); ` `} ` `} ` ` `  `// This code is contributed by Rajput-Ji `

## C#

 `// C# program to count the number  ` `// of ordered sets not containing  ` `// consecutive numbers ` `using` `System; ` `class` `GFG{ ` ` `  `// DP table ` `static` `int` `[,]dp = ``new` `int``[500, 500]; ` ` `  `// Function to calculate the count ` `// of ordered set for a given size ` `static` `int` `CountSets(``int` `x, ``int` `pos) ` `{ ` `     `  `    ``// Base cases ` `    ``if` `(x <= 0)  ` `    ``{ ` `        ``if` `(pos == 0) ` `            ``return` `1; ` `        ``else` `            ``return` `0; ` `    ``} ` `    ``if` `(pos == 0) ` `        ``return` `1; ` ` `  `    ``// If subproblem has been  ` `    ``// soved before ` `    ``if` `(dp[x,pos] != -1) ` `        ``return` `dp[x, pos]; ` ` `  `    ``int` `answer = CountSets(x - 1, pos) +  ` `                 ``CountSets(x - 2, pos - 1); ` ` `  `    ``// Store and return answer to  ` `    ``// this subproblem ` `    ``return` `dp[x, pos] = answer; ` `} ` ` `  `// Function returns the count  ` `// of all ordered sets ` `static` `int` `CountOrderedSets(``int` `n) ` `{ ` `     `  `    ``// Prestore the factorial value ` `    ``int` `[]factorial = ``new` `int``[10000]; ` `    ``factorial[0] = 1; ` ` `  `    ``for``(``int` `i = 1; i < 10000; i++) ` `        ``factorial[i] = factorial[i - 1] * i; ` ` `  `    ``int` `answer = 0; ` ` `  `    ``// Initialise the dp table ` `    ``for``(``int` `i = 0; i < 500; i++) ` `    ``{ ` `        ``for``(``int` `j = 0; j < 500; j++) ` `        ``{ ` `            ``dp[i, j] = -1; ` `        ``} ` `    ``} ` ` `  `    ``// Iterate all ordered set sizes and find  ` `    ``// the count for each one maximum ordered ` `    ``// set size will be smaller than N as all ` `    ``// elements are distinct and non consecutive. ` `    ``for``(``int` `i = 1; i <= n; i++) ` `    ``{ ` ` `  `        ``// Multiply ny size! for all the  ` `        ``// arrangements because sets  ` `        ``// are ordered. ` `        ``int` `sets = CountSets(n, i) * factorial[i]; ` `         `  `        ``// Add to total answer ` `        ``answer = answer + sets; ` `    ``} ` `    ``return` `answer; ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``int` `N = 3; ` ` `  `    ``Console.Write(CountOrderedSets(N)); ` `} ` `} ` ` `  `// This code is contributed by sapnasingh4991`

Output:

```5

```

Time Complexity: O(N2)

My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.