# Count all indices of cyclic regular parenthesis

Given a string S of length N, consisting of only opening ‘(‘ and closing ‘)‘ parenthesis. The task is to find all indices ‘K‘ such that S[K…N-1] + S[0…K-1] is a regular parenthesis.

A regular parentheses string is either empty (“”), “(” + str1 + “)”, or str1 + str2, where str1 and str2 are regular parentheses strings.
For example: “”, “()”, “(())()”, and “(()(()))” are regular parentheses strings.

Examples:

Input: str = “)()(”
Output:
Explanation:
For K = 1, S = ()(), which is regular.
For K = 3, S = ()(), which is regular.
Input: S = “())(”
Output:
Explanation:
For K = 3, S = (()), which is regular.

Naive Approach: The naive approach is to split the given string str at every possible index(say K) and check whether str[K, N-1] + str[0, K-1] is palindromic or not. If yes then print that particular value of K.
Time Complexity: O(N2
Auxiliary Space: O(1)
Efficient Approach: The idea is to observe that if at any index(say K) where the count of closing brackets is greater than the count of opening brackets then that index is the possible index of splitting the string. Below are the steps:

1. The partition is only possible when the count the number of opening brackets must be equal to the number of closing brackets. Else we can’t form any partition to balanced the parenthesis.
2. Create an auxiliary array(say aux[]) of size length of the string.
3. Traverse the given string if character at any index(say i) is ‘(‘ then update aux[i] to 1 else update strong>aux[i] to -1.
4. The frequency of the minimum element in the above auxiliary array is the required number of splitting(say at index K) to make S[K…N-1] + S[0…K-1] a regular parenthesis string.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach`   `#include ` `using` `namespace` `std;`   `// Function to find all indices which` `// cyclic shift leads to get` `// balanced parenthesis` `int` `countCyclicShifts(string& S, ``int` `n)` `{` `    ``int` `aux[n] = { 0 };`   `    ``// Create auxiliary array` `    ``for` `(``int` `i = 0; i < n; ++i) {` `        ``if` `(S[i] == ``'('``)` `            ``aux[i] = 1;` `        ``else` `            ``aux[i] = -1;` `    ``}`   `    ``// Finding prefix sum and` `    ``// minimum element` `    ``int` `mn = aux;`   `    ``for` `(``int` `i = 1; i < n; ++i) {` `        ``aux[i] += aux[i - 1];`   `        ``// Update the minimum element` `        ``mn = min(mn, aux[i]);` `    ``}`   `    ``// ChecK if count of '(' and` `    ``// ')' are equal` `    ``if` `(aux[n - 1] != 0)` `        ``return` `0;`   `    ``// Find count of minimum` `    ``// element` `    ``int` `count = 0;`   `    ``// Find the frequency of mn` `    ``for` `(``int` `i = 0; i < n; ++i) {` `        ``if` `(aux[i] == mn)` `            ``count++;` `    ``}`   `    ``// Return the count` `    ``return` `count;` `}`   `// Driver Code` `int` `main()` `{` `    ``// Given string S` `    ``string S = ``")()("``;`   `    ``int` `N = S.length();`   `    ``// Function Call` `    ``cout << countCyclicShifts(S, N);` `    ``return` `0;` `}`

## Java

 `// Java program for the above approach ` `import` `java.util.*;`   `class` `GFG{` `    `  `// Function to find all indices which ` `// cyclic shift leads to get ` `// balanced parenthesis ` `static` `int` `countCyclicShifts(String S, ``int` `n)` `{` `    `  `    ``// Create auxiliary array` `    ``int``[] aux = ``new` `int``[n]; ` `    `  `    ``for``(``int` `i = ``0``; i < n; ++i) ` `    ``{` `       ``if` `(S.charAt(i) == ``'('``)` `           ``aux[i] = ``1``; ` `       ``else` `           ``aux[i] = -``1``;` `    ``}` `    `  `    ``// Finding prefix sum and ` `    ``// minimum element` `    ``int` `mn = aux[``0``];` `    `  `    ``for``(``int` `i = ``1``; i < n; ++i)` `    ``{` `       ``aux[i] += aux[i - ``1``];` `       `  `       ``// Update the minimum element ` `       ``mn = Math.min(mn, aux[i]); ` `    ``}` `    `  `    ``// Check if count of '(' and ')'` `    ``// are equal ` `    ``if` `(aux[n - ``1``] != ``0``) ` `        ``return` `0``; ` `    `  `    ``// Find count of minimum ` `    ``// element ` `    ``int` `count = ``0``; ` `    `  `    ``// Find the frequency of mn ` `    ``for``(``int` `i = ``0``; i < n; ++i)` `    ``{` `       ``if` `(aux[i] == mn) ` `           ``count++; ` `    ``}` `    `  `    ``// Return the count ` `    ``return` `count;` `}`   `// Driver code ` `public` `static` `void` `main(String[] args) ` `{` `    `  `    ``// Given string S ` `    ``String S = ``")()("``; ` `        `  `    ``// length of the string S ` `    ``int` `N = S.length();` `        `  `    ``System.out.print(countCyclicShifts(S, N));` `}` `}`   `// This code is contributed by sanjoy_62`

## Python3

 `# Python3 program for the above approach`   `# Function to find all indices which` `# cyclic shift leads to get` `# balanced parenthesis` `def` `countCyclicShifts(S, n):` `    `  `    ``aux ``=` `[``0` `for` `i ``in` `range``(n)]`   `    ``# Create auxiliary array` `    ``for` `i ``in` `range``(``0``, n):` `        ``if` `(S[i] ``=``=` `'('``):` `            ``aux[i] ``=` `1` `        ``else``:` `            ``aux[i] ``=` `-``1`   `    ``# Finding prefix sum and` `    ``# minimum element` `    ``mn ``=` `aux[``0``]`   `    ``for` `i ``in` `range``(``1``, n):` `        ``aux[i] ``+``=` `aux[i ``-` `1``]`   `        ``# Update the minimum element` `        ``mn ``=` `min``(mn, aux[i])`   `    ``# ChecK if count of '(' and` `    ``# ')' are equal` `    ``if` `(aux[n ``-` `1``] !``=` `0``):` `        ``return` `0`   `    ``# Find count of minimum` `    ``# element` `    ``count ``=` `0`   `    ``# Find the frequency of mn` `    ``for` `i ``in` `range``(``0``, n):` `        ``if` `(aux[i] ``=``=` `mn):` `            ``count ``+``=` `1`   `    ``# Return the count` `    ``return` `count`   `# Driver Code`   `# Given string S` `S ``=` `")()("` `N ``=` `len``(S)`   `# Function call` `print``(countCyclicShifts(S, N))`   `# This code is contributed by Sanjit_Prasad`

## C#

 `// C# program for the above approach ` `using` `System;`   `class` `GFG{` `    `  `// Function to find all indices which ` `// cyclic shift leads to get ` `// balanced parenthesis ` `static` `int` `countCyclicShifts(``string` `S, ``int` `n)` `{` `    `  `    ``// Create auxiliary array` `    ``int``[] aux = ``new` `int``[n]; ` `    `  `    ``for``(``int` `i = 0; i < n; ++i) ` `    ``{` `        ``if` `(S[i] == ``'('``)` `            ``aux[i] = 1; ` `        ``else` `            ``aux[i] = -1;` `    ``}` `    `  `    ``// Finding prefix sum and ` `    ``// minimum element` `    ``int` `mn = aux;` `    `  `    ``for``(``int` `i = 1; i < n; ++i)` `    ``{` `        ``aux[i] += aux[i - 1];` `            `  `        ``// Update the minimum element ` `        ``mn = Math.Min(mn, aux[i]); ` `    ``}` `    `  `    ``// Check if count of '(' and ')'` `    ``// are equal ` `    ``if` `(aux[n - 1] != 0) ` `        ``return` `0; ` `    `  `    ``// Find count of minimum ` `    ``// element ` `    ``int` `count = 0; ` `    `  `    ``// Find the frequency of mn ` `    ``for``(``int` `i = 0; i < n; ++i)` `    ``{` `        ``if` `(aux[i] == mn) ` `            ``count++; ` `    ``}` `    `  `    ``// Return the count ` `    ``return` `count;` `}`   `// Driver code ` `public` `static` `void` `Main(``string``[] args) ` `{` `    `  `    ``// Given string S ` `    ``string` `S = ``")()("``; ` `        `  `    ``// length of the string S ` `    ``int` `N = S.Length;` `        `  `    ``Console.Write(countCyclicShifts(S, N));` `}` `}`   `// This code is contributed by rutvik_56`

## Javascript

 ``

Output:

`2`

Time Complexity: O(N), where N is the length of the string.
Auxiliary Space: O(N), where N is the length of the string.

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next