# Count pairs of parentheses sequences such that parentheses are balanced

Given N bracket sequences, the task is to find the number of pairs of bracket sequences by joining which can be obtained a balanced bracket sequence as a whole. A bracket parentheses sequence can only be a part of a single pair.

Examples:

```Input: { ")())", ")", "((", "((", "(", ")", ")"}
Output:  2
Bracket sequence {1, 3} and {5, 6}

Input: {"()", "(())", "(())", "()"}
Output: 2
Since all brackets are balanced, hence we can form 2 pairs with 4.
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: The following steps can be followed to solve the above problem:

• Count required opening and closing brackets, of individuals.
• If required closing brackets > 0 and opening brackets is 0, then hash the bracket’s required closing number.
• Similarly, if required opening brackets > 0 and closing brackets is 0, then hash the bracket’s required opening number.
• Count the balanced bracket sequences.
• Add (number of balanced bracket sequences/2) to the number of pairs.
• For every number of sequences which requires same number of opening brackets, min(hash[open], hash[close]) will be added to the number of pairs

Below is the implementation of the above approach:

## C++

 `// C++ program to count the number of pairs ` `// of balanced parentheses ` `#include ` `using` `namespace` `std; ` ` `  `// Function to count the number of pairs ` `int` `countPairs(string bracks[], ``int` `num) ` `{ ` ` `  `    ``// Hashing function to count the ` `    ``// opening and closing brackets ` `    ``unordered_map<``int``, ``int``> open, close; ` ` `  `    ``int` `cnt = 0; ` ` `  `    ``// Traverse for all bracket sequences ` `    ``for` `(``int` `i = 0; i < num; i++) { ` ` `  `        ``// Get the string ` `        ``string s = bracks[i]; ` ` `  `        ``int` `l = s.length(); ` ` `  `        ``// Counts the opening and closing required ` `        ``int` `op = 0, cl = 0; ` ` `  `        ``// Traverse in the string ` `        ``for` `(``int` `j = 0; j < l; j++) { ` ` `  `            ``// If it is a opening bracket ` `            ``if` `(s[j] == ``'('``) ` `                ``op++; ` `            ``else` `// Closing bracket ` `            ``{ ` ` `  `                ``// If openings are there, then close it ` `                ``if` `(op) ` `                    ``op--; ` `                ``else` `// Else increase count of closing ` `                    ``cl++; ` `            ``} ` `        ``} ` ` `  `        ``// If requirements of openings ` `        ``// are there and no closing ` `        ``if` `(op && !cl) ` `            ``open[op]++; ` ` `  `        ``// If requirements of closing ` `        ``// are there and no opening ` `        ``if` `(cl && !op) ` `            ``close[cl]++; ` ` `  `        ``// Perfect ` `        ``if` `(!op && !cl) ` `            ``cnt++; ` `    ``} ` ` `  `    ``// Divide by two since two ` `    ``// perfect makes one pair ` `    ``cnt = cnt / 2; ` ` `  `    ``// Traverse in the open and find ` `    ``// corresponding minimum ` `    ``for` `(``auto` `it : open) ` `        ``cnt += min(it.second, close[it.first]); ` ` `  `    ``return` `cnt; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``string bracks[] = { ``")())"``, ``")"``, ``"(("``, ``"(("``, ``"("``, ``")"``, ``")"` `}; ` `    ``int` `num = ``sizeof``(bracks) / ``sizeof``(bracks); ` ` `  `    ``cout << countPairs(bracks, num); ` `} `

## Java

 `// Java program to count the number of pairs  ` `// of balanced parentheses  ` `import` `java.util.HashMap; ` ` `  `class` `GFG  ` `{ ` ` `  `// Function to count the number of pairs ` `static` `int` `countPairs(String[] bracks, ``int` `num) ` `{ ` ` `  `    ``// Hashing function to count the ` `    ``// opening and closing brackets ` `    ``HashMap open = ``new` `HashMap<>(); ` `    ``HashMap close = ``new` `HashMap<>(); ` ` `  `    ``int` `cnt = ``0``; ` ` `  `    ``// Traverse for all bracket sequences ` `    ``for` `(``int` `i = ``0``; i < num; i++)  ` `    ``{ ` ` `  `        ``// Get the string ` `        ``String s = bracks[i]; ` `        ``int` `l = s.length(); ` ` `  `        ``// Counts the opening and closing required ` `        ``int` `op = ``0``, cl = ``0``; ` ` `  `        ``// Traverse in the string ` `        ``for` `(``int` `j = ``0``; j < l; j++)  ` `        ``{ ` ` `  `            ``// If it is a opening bracket ` `            ``if` `(s.charAt(j) == ``'('``) ` `                ``op++; ` ` `  `            ``// Closing bracket ` `            ``else`  `            ``{ ` ` `  `                ``// If openings are there, then close it ` `                ``if` `(op != ``0``) ` `                    ``op--; ` ` `  `                ``// Else increase count of closing ` `                ``else` `                    ``cl++; ` `            ``} ` `        ``} ` ` `  `        ``// If requirements of openings ` `        ``// are there and no closing ` `        ``if` `(op != ``0` `&& cl == ``0``) ` `            ``open.put(op, open.get(op) == ``null` `?  ` `                     ``1` `: open.get(op) + ``1``); ` ` `  `        ``// If requirements of closing ` `        ``// are there and no opening ` `        ``if` `(cl != ``0` `&& op == ``0``) ` `            ``close.put(cl, close.get(cl) == ``null` `?  ` `                      ``1` `: close.get(cl) + ``1``); ` ` `  `        ``// Perfect ` `        ``if` `(op == ``0` `&& cl == ``0``) ` `            ``cnt++; ` `    ``} ` ` `  `    ``// Divide by two since two ` `    ``// perfect makes one pair ` `    ``cnt /= ``2``; ` ` `  `    ``// Traverse in the open and find ` `    ``// corresponding minimum ` `    ``for` `(HashMap.Entry it : open.entrySet()) ` `        ``cnt += Math.min(it.getValue(), ` `              ``close.get(it.getKey())); ` ` `  `    ``return` `cnt; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main(String[] args)  ` `{ ` `    ``String[] bracks = { ``")())"``, ``")"``, ``"(("``,  ` `                        ``"(("``, ``"("``, ``")"``, ``")"` `}; ` `    ``int` `num = bracks.length; ` ` `  `    ``System.out.println(countPairs(bracks, num)); ` `} ` `} ` ` `  `// This code is contributed by ` `// sanjeev2552 `

## Python3

 `# Python3 program to count the number of pairs ` `# of balanced parentheses ` `import` `math as mt ` ` `  `# Function to count the number of pairs ` `def` `countPairs(bracks, num): ` ` `  `    ``# Hashing function to count the ` `    ``# opening and closing brackets ` `    ``openn``=``dict``() ` `    ``close``=``dict``() ` ` `  `    ``cnt ``=` `0` ` `  `    ``# Traverse for all bracket sequences ` `    ``for` `i ``in` `range``(num):  ` ` `  `        ``# Get the string ` `        ``s ``=` `bracks[i] ` ` `  `        ``l ``=` `len``(s) ` ` `  `        ``# Counts the opening and closing required ` `        ``op,cl ``=` `0``,``0` ` `  `        ``# Traverse in the string ` `        ``for` `j ``in` `range``(l): ` `            ``# If it is a opening bracket ` `            ``if` `(s[j] ``=``=` `'('``): ` `                ``op``+``=``1` `            ``else``: ``# Closing bracket ` `             `  ` `  `                ``# If openings are there, then close it ` `                ``if` `(op): ` `                    ``op``-``=``1` `                ``else``: ``# Else increase count of closing ` `                    ``cl``+``=``1` `             `  `         `  ` `  `        ``# If requirements of openings ` `        ``# are there and no closing ` `        ``if` `(op ``and` `cl``=``=``0``): ` `            ``if` `op ``in` `openn.keys(): ` `                ``openn[op]``+``=``1` `            ``else``: ` `                ``openn[op]``=``1` `                 `  ` `  `        ``# If requirements of closing ` `        ``# are there and no opening ` `        ``if` `(cl ``and` `op``=``=``0``): ` `            ``if` `cl ``in` `openn.keys(): ` `                ``close[cl]``+``=``1` `            ``else``: ` `                ``close[cl]``=``1` `             `  ` `  `        ``# Perfect ` `        ``if` `(op``=``=``0` `and` `cl``=``=``0``): ` `            ``cnt``+``=``1` `     `  ` `  `    ``# Divide by two since two ` `    ``# perfect makes one pair ` `    ``cnt ``=` `cnt ``/``/``2` ` `  `    ``# Traverse in the open and find ` `    ``# corresponding minimum ` `    ``for` `it ``in` `openn: ` `        ``cnt ``+``=` `min``(openn[it], close[it]) ` ` `  `    ``return` `cnt ` ` `  ` `  `# Driver Code ` `bracks``=` `[``")())"``, ``")"``, ``"(("``, ``"(("``, ``"("``, ``")"``, ``")"` `] ` `num ``=` `len``(bracks) ` ` `  `print``(countPairs(bracks, num)) ` ` `  `#This code is contributed by Mohit kumar 29 `

Output:

```2
```

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.

Article Tags :
Practice Tags :

1

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.