Related Articles
Count distinct regular bracket sequences which are not N periodic
• Difficulty Level : Easy
• Last Updated : 17 Mar, 2021

Given an integer N, the task is to find the number of distinct bracket sequences that can be formed using 2 * N brackets such that the sequence is not N-periodic.

A bracket sequence str of length 2 * N is said to be N-periodic if the sequence can be split into two equal substrings having same regular bracket sequence.
A regular bracket sequence is a sequence in the following way:

• An empty string is a regular bracket sequence.
• If s & t are regular bracket sequences, then s + t is a regular bracket sequence.

Examples:

Input: N = 3
Output:
Explanation:
There will be 5 distinct regular bracket sequences of length 2 * N = ()()(), ()(()), (())(), (()()), ((()))
Now, none of the sequences are N-periodic. Therefore, the output is 5.

Input: N = 4
Output: 12
Explanation:
There will be 14 distinct regular bracket sequences of length 2*N which are
()()()(), ()()(()), ()(())(), ()(()()), ()((())), (())()(), (())(()), (()())(), (()()()), (()(())), ((()))(), ((())()), ((()())), (((())))
Out of these 14 regular sequences, two of them are N periodic which are
()()()() and (())(()). They have a period of N.
Therefore, the distinct regular bracket sequences of length 2 * N which are not N-periodic are 14 – 2 = 12.

Approach: The idea is to calculate the total number of regular bracket sequences possible of length 2 * N and then to subtract the number of bracket sequences which are N-periodic from it. Below are the steps:

1. To find the number of regular bracket sequences of length 2*N, use the Catalan number formula.
2. For a sequence of length 2*N to be N periodic, N should be even because if N is odd then the sequence of length 2*N cannot be a regular sequence and have a period of N at the same time.
3. Since the concatenation of two similar non-regular bracket sequences cannot make a sequence regular, so both subsequences of length N should be regular.
4. Reduce the number of regular bracket sequences of length N(if N is even) from the number of regular bracket sequences of length 2*N to get the desired result.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function that finds the value of``// Binomial Coefficient C(n, k)``unsigned ``long` `int``binomialCoeff(unsigned ``int` `n,``              ``unsigned ``int` `k)``{``    ``unsigned ``long` `int` `res = 1;` `    ``// Since C(n, k) = C(n, n - k)``    ``if` `(k > n - k)``        ``k = n - k;` `    ``// Calculate the value of``    ``// [n*(n - 1)*---*(n - k + 1)] /``    ``// [k*(k - 1)*---*1]``    ``for` `(``int` `i = 0; i < k; ++i) {``        ``res *= (n - i);``        ``res /= (i + 1);``    ``}` `    ``// Return the C(n, k)``    ``return` `res;``}` `// Binomial coefficient based function to``// find nth catalan number in O(n) time``unsigned ``long` `int` `catalan(unsigned ``int` `n)``{``    ``// Calculate value of 2nCn``    ``unsigned ``long` `int` `c``        ``= binomialCoeff(2 * n, n);` `    ``// Return C(2n, n)/(n+1)``    ``return` `c / (n + 1);``}` `// Function to find possible ways to``// put balanced  parenthesis in an``// expression of length n``unsigned ``long` `int` `findWays(unsigned n)``{``    ``// If n is odd, not possible to``    ``// create any valid parentheses``    ``if` `(n & 1)``        ``return` `0;` `    ``// Otherwise return n/2th``    ``// Catalan Numer``    ``return` `catalan(n / 2);``}` `void` `countNonNPeriodic(``int` `N)``{` `    ``// Difference between counting ways``    ``// of 2*N and N is the result``    ``cout << findWays(2 * N)``                ``- findWays(N);``}` `// Driver Code``int` `main()``{``    ``// Given value of N``    ``int` `N = 4;` `    ``// Function Call``    ``countNonNPeriodic(N);` `    ``return` `0;``}`

## Java

 `// Java program for above approach``import` `java.io.*;` `class` `GFG{``    ` `// Function that finds the value of``// Binomial Coefficient C(n, k)``static` `long` `binomialCoeff(``int` `n, ``int` `k)``{``    ``long` `res = ``1``;` `    ``// Since C(n, k) = C(n, n - k)``    ``if` `(k > n - k)``        ``k = n - k;` `    ``// Calculate the value of``    ``// [n*(n - 1)*---*(n - k + 1)] /``    ``// [k*(k - 1)*---*1]``    ``for``(``int` `i = ``0``; i < k; ++i)``    ``{``        ``res *= (n - i);``        ``res /= (i + ``1``);``    ``}` `    ``// Return the C(n, k)``    ``return` `res;``}` `// Binomial coefficient based function to``// find nth catalan number in O(n) time``static` `long` `catalan(``int` `n)``{``    ` `    ``// Calculate value of 2nCn``    ``long` `c = binomialCoeff(``2` `* n, n);` `    ``// Return C(2n, n)/(n+1)``    ``return` `c / (n + ``1``);``}` `// Function to find possible ways to``// put balanced parenthesis in an``// expression of length n``static` `long` `findWays(``int` `n)``{``    ` `    ``// If n is odd, not possible to``    ``// create any valid parentheses``    ``if` `((n & ``1``) == ``1``)``        ``return` `0``;` `    ``// Otherwise return n/2th``    ``// Catalan Numer``    ``return` `catalan(n / ``2``);``}` `static` `void` `countNonNPeriodic(``int` `N)``{``    ` `    ``// Difference between counting ways``    ``// of 2*N and N is the result``    ``System.out.println(findWays(``2` `* N) -``                       ``findWays(N));``}` `// Driver code``public` `static` `void` `main (String[] args)``{``    ` `    ``// Given value of N``    ``int` `N = ``4``;``    ` `    ``// Function call``    ``countNonNPeriodic(N);``}``}` `// This code is contributed by offbeat`

## Python3

 `# Python3 program for``# the above approach` `# Function that finds the value of``# Binomial Coefficient C(n, k)``def` `binomialCoeff(n, k):``    ``res ``=` `1`` ` `    ``# Since C(n, k) = C(n, n - k)``    ``if` `(k > n ``-` `k):``        ``k ``=` `n ``-` `k`` ` `    ``# Calculate the value of``    ``# [n*(n - 1)*---*(n - k + 1)] /``    ``# [k*(k - 1)*---*1]``    ``for` `i ``in` `range``(k):``    ` `        ``res ``=` `res ``*` `(n ``-` `i)``        ``res ``=` `res ``/``/` `(i ``+` `1``)`` ` `    ``# Return the C(n, k)``    ``return` `res`` ` `# Binomial coefficient based function to``# find nth catalan number in O(n) time``def` `catalan(n):``     ` `    ``# Calculate value of 2nCn``    ``c ``=` `binomialCoeff(``2` `*` `n, n)`` ` `    ``# Return C(2n, n)/(n+1)``    ``return` `c ``/``/` `(n ``+` `1``)`` ` `# Function to find possible ways to``# put balanced parenthesis in an``# expression of length n``def` `findWays(n):` `    ``# If n is odd, not possible to``    ``# create any valid parentheses``    ``if` `((n & ``1``) ``=``=` `1``):``        ``return` `0``      ` `    ``# Otherwise return n/2th``    ``# Catalan Numer``    ``return` `catalan(n ``/``/` `2``)``  ` `def` `countNonNPeriodic(N):``     ` `    ``# Difference between counting ways``    ``# of 2*N and N is the result``    ``print``(findWays(``2` `*` `N) ``-` `findWays(N))` `# Driver code``# Given value of N``N ``=` `4``     ` `# Function call``countNonNPeriodic(N)` `# This code is contributed by divyeshrabadiya07`

## C#

 `// C# program for above approach``using` `System;``using` `System.Collections.Generic; ` `class` `GFG{``  ` `// Function that finds the value of``// Binomial Coefficient C(n, k)``static` `long` `binomialCoeff(``int` `n, ``int` `k)``{``    ``long` `res = 1;`` ` `    ``// Since C(n, k) = C(n, n - k)``    ``if` `(k > n - k)``        ``k = n - k;`` ` `    ``// Calculate the value of``    ``// [n*(n - 1)*---*(n - k + 1)] /``    ``// [k*(k - 1)*---*1]``    ``for``(``int` `i = 0; i < k; ++i)``    ``{``        ``res *= (n - i);``        ``res /= (i + 1);``    ``}`` ` `    ``// Return the C(n, k)``    ``return` `res;``}`` ` `// Binomial coefficient based function to``// find nth catalan number in O(n) time``static` `long` `catalan(``int` `n)``{``     ` `    ``// Calculate value of 2nCn``    ``long` `c = binomialCoeff(2 * n, n);`` ` `    ``// Return C(2n, n)/(n+1)``    ``return` `c / (n + 1);``}`` ` `// Function to find possible ways to``// put balanced parenthesis in an``// expression of length n``static` `long` `findWays(``int` `n)``{``     ` `    ``// If n is odd, not possible to``    ``// create any valid parentheses``    ``if` `((n & 1) == 1)``        ``return` `0;`` ` `    ``// Otherwise return n/2th``    ``// Catalan Numer``    ``return` `catalan(n / 2);``}`` ` `static` `void` `countNonNPeriodic(``int` `N)``{``     ` `    ``// Difference between counting ways``    ``// of 2*N and N is the result``    ``Console.Write(findWays(2 * N) -``                  ``findWays(N));``}``  ` `// Driver Code``public` `static` `void` `Main(``string``[] args)``{``     ` `    ``// Given value of N``    ``int` `N = 4;``     ` `    ``// Function call``    ``countNonNPeriodic(N);``}``}` `// This code is contributed by rutvik_56`

## Javascript

 ``
Output:
`12`

Time Complexity: O(N)
Auxiliary Space: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live

My Personal Notes arrow_drop_up