# Count distinct regular bracket sequences which are not N periodic

• Difficulty Level : Easy
• Last Updated : 20 Aug, 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 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