 GFG App
Open App Browser
Continue

# Count distinct regular bracket sequences which are not N periodic

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

My Personal Notes arrow_drop_up