Related Articles

# Count the number of ordered sets not containing consecutive numbers

• Last Updated : 08 Jun, 2021

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 a 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 sizes.
• 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 include 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`

## Javascript

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

## Python3

 `# Python3 program to count the number``# of ordered sets not containing``# consecutive numbers` `# DP table``dp ``=` `[[``-``1` `for` `j ``in` `range``(``500``)]``          ``for` `i ``in` `range``(``500``)]`` ` `# 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`` ` `    ``# If subproblem has been``    ``# soved before``    ``if` `(dp[x][pos] !``=` `-``1``):``        ``return` `dp[x][pos]`` ` `    ``answer ``=` `(CountSets(x ``-` `1``, pos) ``+``              ``CountSets(x ``-` `2``, pos ``-` `1``))`` ` `    ``# Store and return answer to``    ``# this subproblem``    ``dp[x][pos] ``=` `answer``    ` `    ``return` `answer` `# Function returns the count``# of all ordered sets``def` `CountOrderedSets(n):` `    ``# Prestore the factorial value``    ``factorial ``=` `[``0` `for` `i ``in` `range``(``10000``)]``    ``factorial[``0``] ``=` `1``    ` `    ``for` `i ``in` `range``(``1``, ``10000``):``        ``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``):`` ` `        ``# 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 rutvik_56`

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

## Javascript

 ``
Output:
`5`

Time Complexity: O(N2)

My Personal Notes arrow_drop_up