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

C * S!

  • .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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to Count the number of
// ordered sets not containing
// consecutive numbers
#include <bits/stdc++.h>
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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


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

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to Count the number
// of ordered sets not containing
// consecutive numbers
#include <bits/stdc++.h>
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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Output: 

5




 

Time Complexity: O(N2)
 

 

competitive-programming-img




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.