# Minimum number of bracket reversals needed to make an expression balanced | Set – 2

Given an expression with only ‘}’ and ‘{‘. The expression may not be balanced. The task is to find minimum number of bracket reversals to make the expression balanced.

Examples:

```Input : exp = "}{"
Output : 2
We need to change '}' to '{' and '{' to
'}' so that the expression becomes balanced,
the balanced expression is '{}'

Input : exp = "}{{}}{{{"
Output : 3
The balanced expression is "{{{}}{}}"
```

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

The solution discussed in previous post requires O(n) extra space. The problem can be solved using constant space.

The idea is to use two variables open and close where, open represents number of unbalanced opening brackets and close represents number of unbalanced close brackets.

Traverse the string and if current character is an opening bracket increment open. If current character is a closing bracket then check if there are unbalanced opening brackets(open > 0). If yes then decrement open else increment close as this bracket is unbalanced.

Below is the implementation of above approach:

## C++

 `// C++ program to find minimum number of ` `// reversals required to balance an expression ` `#include ` `using` `namespace` `std; ` ` `  `// Returns count of minimum reversals for making ` `// expr balanced. Returns -1 if expr cannot be ` `// balanced. ` `int` `countMinReversals(string expr) ` `{ ` `    ``int` `len = expr.length(); ` ` `  `    ``// length of expression must be even to make ` `    ``// it balanced by using reversals. ` `    ``if` `(len % 2) ` `        ``return` `-1; ` ` `  `    ``// To store number of reversals required. ` `    ``int` `ans = 0; ` ` `  `    ``int` `i; ` ` `  `    ``// To store number of unbalanced opening brackets. ` `    ``int` `open = 0; ` ` `  `    ``// To store number of unbalanced closing brackets. ` `    ``int` `close = 0; ` ` `  `    ``for` `(i = 0; i < len; i++) { ` ` `  `        ``// If current bracket is open then increment ` `        ``// open count. ` `        ``if` `(expr[i] == ``'{'``) ` `            ``open++; ` ` `  `        ``// If current bracket is close, check if it ` `        ``// balances opening bracket. If yes then ` `        ``// decrement count of unbalanced opening ` `        ``// bracket else increment count of ` `        ``// closing bracket. ` `        ``else` `{ ` `            ``if` `(!open) ` `                ``close++; ` `            ``else` `                ``open--; ` `        ``} ` `    ``} ` ` `  `    ``ans = (close / 2) + (open / 2); ` ` `  `    ``// For the case: "}{" or when one closing and ` `    ``// one opening bracket remains for pairing, then ` `    ``// both need to be reversed. ` `    ``close %= 2; ` `    ``open %= 2; ` `    ``if` `(close) ` `        ``ans += 2; ` ` `  `    ``return` `ans; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``string expr = ``"}}{{"``; ` ` `  `    ``cout << countMinReversals(expr); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program to find minimum number of  ` `// reversals required to balance an expression  ` `class` `GFG ` `{ ` ` `  `// Returns count of minimum reversals for making  ` `// expr balanced. Returns -1 if expr cannot be  ` `// balanced.  ` `static` `int` `countMinReversals(String expr)  ` `{  ` `    ``int` `len = expr.length();  ` ` `  `    ``// length of expression must be even to make  ` `    ``// it balanced by using reversals.  ` `    ``if` `(len % ``2` `!= ``0``)  ` `        ``return` `-``1``;  ` ` `  `    ``// To store number of reversals required.  ` `    ``int` `ans = ``0``;  ` ` `  `    ``int` `i;  ` ` `  `    ``// To store number of unbalanced opening brackets.  ` `    ``int` `open = ``0``;  ` ` `  `    ``// To store number of unbalanced closing brackets.  ` `    ``int` `close = ``0``;  ` ` `  `    ``for` `(i = ``0``; i < len; i++) ` `    ``{  ` ` `  `        ``// If current bracket is open then increment  ` `        ``// open count.  ` `        ``if` `(expr.charAt(i) == ``'{'``)  ` `            ``open++;  ` ` `  `        ``// If current bracket is close, check if it  ` `        ``// balances opening bracket. If yes then  ` `        ``// decrement count of unbalanced opening  ` `        ``// bracket else increment count of  ` `        ``// closing bracket.  ` `        ``else`  `        ``{  ` `            ``if` `(open == ``0``)  ` `                ``close++;  ` `            ``else` `                ``open--;  ` `        ``}  ` `    ``}  ` ` `  `    ``ans = (close / ``2``) + (open / ``2``);  ` ` `  `    ``// For the case: "}{" or when one closing and  ` `    ``// one opening bracket remains for pairing, then  ` `    ``// both need to be reversed.  ` `    ``close %= ``2``;  ` `    ``open %= ``2``;  ` `    ``if` `(close != ``0``)  ` `        ``ans += ``2``;  ` ` `  `    ``return` `ans;  ` `}  ` ` `  `// Driver Code  ` `public` `static` `void` `main(String args[]) ` `{  ` `    ``String expr = ``"}}{{"``;  ` ` `  `    ``System.out.println(countMinReversals(expr));  ` `}  ` `} ` ` `  `// This code is contributed by Arnab Kundu `

## Python3

 `# Python3 program to find minimum number of ` `# reversals required to balance an expression ` ` `  `# Returns count of minimum reversals for  ` `# making expr balanced. Returns -1 if  ` `# expr cannot be balanced. ` `def` `countMinReversals(expr): ` ` `  `    ``length ``=` `len``(expr) ` ` `  `    ``# length of expression must be even to  ` `    ``# make it balanced by using reversals. ` `    ``if` `length ``%` `2``: ` `        ``return` `-``1` ` `  `    ``# To store number of reversals required. ` `    ``ans ``=` `0` ` `  `    ``# To store number of unbalanced ` `    ``# opening brackets. ` `    ``open` `=` `0` ` `  `    ``# To store number of unbalanced  ` `    ``# closing brackets. ` `    ``close ``=` `0` ` `  `    ``for` `i ``in` `range``(``0``, length):  ` ` `  `        ``# If current bracket is open  ` `        ``# then increment open count. ` `        ``if` `expr[i] ``=``=` `"": ` `            ``open` `+``=` `1` ` `  `        ``# If current bracket is close, check if it ` `        ``# balances opening bracket. If yes then ` `        ``# decrement count of unbalanced opening ` `        ``# bracket else increment count of ` `        ``# closing bracket. ` `        ``else``: ` `            ``if` `not` `open``: ` `                ``close ``+``=` `1` `            ``else``: ` `                ``open` `-``=` `1` `         `  `    ``ans ``=` `(close ``/``/` `2``) ``+` `(``open` `/``/` `2``) ` ` `  `    ``# For the case: "" or when one closing  ` `    ``# and one opening bracket remains for  ` `    ``# pairing, then both need to be reversed. ` `    ``close ``%``=` `2` `    ``open` `%``=` `2` `     `  `    ``if` `close > ``0``: ` `        ``ans ``+``=` `2` ` `  `    ``return` `ans ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `"__main__"``: ` ` `  `    ``expr ``=` `"}}{{"` `    ``print``(countMinReversals(expr)) ` ` `  `# This code is contributed by Rituraj Jain `

## C#

 `// C# program to find minimum number of  ` `// reversals required to balance an expression  ` `using` `System; ` `     `  `class` `GFG ` `{ ` ` `  `// Returns count of minimum reversals for making  ` `// expr balanced. Returns -1 if expr cannot be  ` `// balanced.  ` `static` `int` `countMinReversals(String expr)  ` `{  ` `    ``int` `len = expr.Length;  ` ` `  `    ``// length of expression must be even to make  ` `    ``// it balanced by using reversals.  ` `    ``if` `(len % 2 != 0)  ` `        ``return` `-1;  ` ` `  `    ``// To store number of reversals required.  ` `    ``int` `ans = 0;  ` ` `  `    ``int` `i;  ` ` `  `    ``// To store number of unbalanced opening brackets.  ` `    ``int` `open = 0;  ` ` `  `    ``// To store number of unbalanced closing brackets.  ` `    ``int` `close = 0;  ` ` `  `    ``for` `(i = 0; i < len; i++) ` `    ``{  ` ` `  `        ``// If current bracket is open then increment  ` `        ``// open count.  ` `        ``if` `(expr[i] == ``'{'``)  ` `            ``open++;  ` ` `  `        ``// If current bracket is close, check if it  ` `        ``// balances opening bracket. If yes then  ` `        ``// decrement count of unbalanced opening  ` `        ``// bracket else increment count of  ` `        ``// closing bracket.  ` `        ``else` `        ``{  ` `            ``if` `(open == 0)  ` `                ``close++;  ` `            ``else` `                ``open--;  ` `        ``}  ` `    ``}  ` ` `  `    ``ans = (close / 2) + (open / 2);  ` ` `  `    ``// For the case: "}{" or when one closing and  ` `    ``// one opening bracket remains for pairing, then  ` `    ``// both need to be reversed.  ` `    ``close %= 2;  ` `    ``open %= 2;  ` `    ``if` `(close != 0)  ` `        ``ans += 2;  ` ` `  `    ``return` `ans;  ` `}  ` ` `  `// Driver Code  ` `public` `static` `void` `Main(String []args) ` `{  ` `    ``String expr = ``"}}{{"``;  ` ` `  `    ``Console.WriteLine(countMinReversals(expr));  ` `}  ` `} ` ` `  `// This code contributed by Rajput-Ji `

Output:

```2
```

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

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

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.