 GeeksforGeeks App
Open App Browser
Continue

# Convert an unbalanced bracket sequence to a balanced sequence

Given an unbalanced bracket sequence of ‘(‘ and ‘)’, convert it into a balanced sequence by adding the minimum number of ‘(‘ at the beginning of the string and ‘)’ at the end of the string.

Examples:

Input: str = “)))()”
Output: “((()))()”

Input: str = “())())(())())”
Output: “(((())())(())())”

## Method 1:

Approach:

• Initialize an empty stack.
• Iterate over each character in the string.
• If the character is an opening parenthesis, push it onto the stack.
• If the character is a closing parenthesis, pop the most recent opening parenthesis from the stack if it matches the closing parenthesis, or push the closing parenthesis onto the stack if there is no matching opening parenthesis.
• After iterating over all characters, count the remaining unbalanced parentheses on the stack and add the appropriate number of opening and closing parentheses to the beginning and end of the string to balance it.

## C++

 `#include ``using` `namespace` `std;` `// c++ code addition` `string balance_parenthesis(string str){``    ``// Initialize an empty stack to keep track of opening and closing parentheses``    ``vector<``int``> st;``    ` `    ``// Iterate over each character in the input string``    ``for``(``auto` `c: str){``        ``// If the character is an opening parenthesis, push it onto the stack``        ``if``(c == ``'('``)``            ``st.push_back(c);``        ``// If the character is a closing parenthesis``        ``else` `if``(c == ``')'``)``            ``// If there is at least one opening parenthesis on the stack,``            ``// pop the most recent one``            ``if``(st.size() > 0 && st[st.size() - 1] == ``'('``)``                ``st.pop_back();``            ``// Otherwise, push the closing parenthesis onto the stack``            ``else``                ``st.push_back(c);``    ``}``    ` `    ``// Count the remaining unbalanced parentheses on the stack``    ``// and add the appropriate number of opening and closing parentheses``    ``// to the beginning and end of the output string to balance it.``    ``int` `closing = 0;``    ``int` `opening = 0;``    ``for``(``int` `i = 0; i < st.size(); i++){``        ``if``(st[i] == ``'('``) closing++;``        ``else` `if``(st[i] == ``')'``)opening++;``    ``}``    ` `    ``// Count the remaining unbalanced parentheses on the stack``    ``// and add the appropriate number of opening and closing parentheses``    ``// to the beginning and end of the output string to balance it.``    ``string res = ``""``;``    ``for``(``int` `i = 0; i < opening ; i++)``        ``res = res + ``'('``;``    ` `    ``res = res + str;``    ``for``(``int` `i = 0; i < closing; i++)``        ``res = res + ``')'``;``    ` `    ``return` `res;``}`   `int` `main(){``    ` `    ` `    ``// Example usage``    ``string str = ``")))()"``;``    ``cout << ``"Input:"` `<< endl;``    ` `    ``cout << str << endl;``    ``string adjusted_s = balance_parenthesis(str);``    ``cout << ``"Balanced Parenthesis: "` `<< endl;``    ``cout << adjusted_s << endl;``       ` `    ``return` `0;` `}``// Code Contributed by Arushi Jindal.`

## Java

 `/*package whatever //do not write package name here */` `import` `java.io.*;``import` `java.util.*;``// java must be defined in a public class.` ` ` `public` `class` `Main {``    ` `    ``// Javascript code addition` `    ``public` `static` `String balance_parenthesis(String string){``        ``// Initialize an empty stack to keep track of opening and closing parentheses``        ``Stack stack = ``new` `Stack();` `        ``// Iterate over each character in the input string``        ``for``(``int` `i = ``0``; i < string.length(); i++){``            ``// If the character is an opening parenthesis, push it onto the stack``            ``Character c = string.charAt(i);` `            ``if``(c == ``'('``)``                ``stack.push(c);``            ``// If the character is a closing parenthesis``            ``else` `if``(c == ``')'``)``                ``// If there is at least one opening parenthesis on the stack,``                ``// pop the most recent one``                ``if``(stack.size() > ``0` `&& stack.peek() == ``'('``)``                    ``stack.pop();``                ``// Otherwise, push the closing parenthesis onto the stack``                ``else``                    ``stack.push(c);``        ``}` `        ``// Count the remaining unbalanced parentheses on the stack``        ``// and add the appropriate number of opening and closing parentheses``        ``// to the beginning and end of the output string to balance it.``        ``int` `closing = ``0``;``        ``int` `opening = ``0``;``        ``while``(stack.size() > ``0``){``            ``if``(stack.peek() == ``'('``) closing++;``            ``else` `if``(stack.peek() == ``')'``)opening++;``            ``stack.pop();``        ``}`  `        ``// Count the remaining unbalanced parentheses on the stack``        ``// and add the appropriate number of opening and closing parentheses``        ``// to the beginning and end of the output string to balance it.``        ``String res = ``""``;``        ``for``(``int` `i = ``0``; i < opening ; i++)``            ``res = res + ``'('``;` `        ``res = res + string;``        ``for``(``int` `i = ``0``; i < closing; i++)``            ``res = res + ``')'``;` `        ``return` `res;``    ``}``    ` `    ``public` `static` `void` `main(String[] args) {` `        ``// Example usage``        ``String string = ``")))()"``;``        ``System.out.println(``"Input:"``);``        ``System.out.println(string);``        ``String adjusted_s = balance_parenthesis(string);``        ``System.out.println(``"Balanced Parenthesis: "``);``        ``System.out.println(adjusted_s);``    ``}``}` `// The code is contributed by Nidhi goel.`

## Python3

 `def` `balance_parenthesis(string):``    ``# Initialize an empty stack to keep track of opening and closing parentheses``    ``stack ``=` `[]``    ` `    ``# Iterate over each character in the input string``    ``for` `c ``in` `string:``        ``# If the character is an opening parenthesis, push it onto the stack``        ``if` `c ``=``=` `'('``:``            ``stack.append(c)``        ``# If the character is a closing parenthesis``        ``elif` `c ``=``=` `')'``:``            ``# If there is at least one opening parenthesis on the stack, pop the most recent one``            ``if` `len``(stack) > ``0` `and` `stack[``-``1``] ``=``=` `'('``:``                ``stack.pop()``            ``# Otherwise, push the closing parenthesis onto the stack``            ``else``:``                ``stack.append(c)``    ` `    ``# Count the remaining unbalanced parentheses on the stack``    ``# and add the appropriate number of opening and closing parentheses``    ``# to the beginning and end of the output string to balance it.``    ``return` `'('` `*` `stack.count(``')'``) ``+` `string ``+` `')'` `*` `stack.count(``'('``)` `# Example usage``string ``=` `")))()"``print``(``"Input:"``)``print``(string)``adjusted_s ``=` `balance_parenthesis(string)``print``(``"Balanced Parenthesis: "``)``print``(adjusted_s)` `#Code Contributed by SR.Dhanush`

## C#

 `// C# code addition``using` `System;``using` `System.Collections.Generic;` `public` `class` `GFG {``    ``public` `static` `string` `balance_parenthesis(``string` `str)``    ``{``        ``// Initialize an empty stack to keep track of``        ``// opening and closing parentheses``        ``List<``char``> st = ``new` `List<``char``>();` `        ``// Iterate over each character in the input string``        ``foreach``(``char` `c ``in` `str)``        ``{``            ``// If the character is an opening parenthesis,``            ``// push it onto the stack``            ``if` `(c == ``'('``)``                ``st.Add(c);``            ``// If the character is a closing parenthesis``            ``else` `if` `(c == ``')'``)``                ``// If there is at least one opening``                ``// parenthesis on the stack, pop the most``                ``// recent one``                ``if` `(st.Count > 0 && st[st.Count - 1] == ``'('``)``                    ``st.RemoveAt(st.Count - 1);``                ``// Otherwise, push the closing parenthesis``                ``// onto the stack``                ``else``                    ``st.Add(c);``        ``}` `        ``// Count the remaining unbalanced parentheses on the``        ``// stack and add the appropriate number of opening``        ``// and closing parentheses to the beginning and end``        ``// of the output string to balance it.``        ``int` `closing = 0;``        ``int` `opening = 0;``        ``foreach``(``char` `c ``in` `st)``        ``{``            ``if` `(c == ``'('``)``                ``closing++;``            ``else` `if` `(c == ``')'``)``                ``opening++;``        ``}` `        ``// Count the remaining unbalanced parentheses on the``        ``// stack and add the appropriate number of opening``        ``// and closing parentheses to the beginning and end``        ``// of the output string to balance it.``        ``string` `res = ``""``;``        ``for` `(``int` `i = 0; i < opening; i++)``            ``res += ``'('``;` `        ``res += str;``        ``for` `(``int` `i = 0; i < closing; i++)``            ``res += ``')'``;` `        ``return` `res;``    ``}` `    ``public` `static` `void` `Main()``    ``{``        ``// Example usage``        ``string` `str = ``")))()"``;``        ``Console.WriteLine(``"Input:"``);``        ` `        ``Console.WriteLine(str);``        ``string` `adjusted_s = balance_parenthesis(str);``        ``Console.WriteLine(``"Balanced Parenthesis:"``);``        ``Console.WriteLine(adjusted_s);``    ``}``}``// This code is contributed by prasad264`

## Javascript

 `// Javascript code addition` `function` `balance_parenthesis(string){``    ``// Initialize an empty stack to keep track of opening and closing parentheses``    ``let stack = [];``    ` `    ``// Iterate over each character in the input string``    ``for``(let c of string){``        ``// If the character is an opening parenthesis, push it onto the stack``        ``if``(c == ``'('``)``            ``stack.push(c)``        ``// If the character is a closing parenthesis``        ``else` `if``(c == ``')'``)``            ``// If there is at least one opening parenthesis on the stack,``            ``// pop the most recent one``            ``if``(stack.length > 0 && stack[-1] == ``'('``)``                ``stack.pop()``            ``// Otherwise, push the closing parenthesis onto the stack``            ``else``                ``stack.push(c)``    ``}``    ` `    ``// Count the remaining unbalanced parentheses on the stack``    ``// and add the appropriate number of opening and closing parentheses``    ``// to the beginning and end of the output string to balance it.``    ``let closing = 0;``    ``let opening = 0;``    ``for``(let i = 0; i < stack.length; i++){``        ``if``(stack[i] == ``'('``) closing++;``        ``else` `if``(stack[i] == ``')'``)opening++;``    ``}``    ` `    ``return` `'('``.repeat(opening-1) + string + ``')'``.repeat(closing-1)``}` `// Example usage``let string = ``")))()"``console.log(``"Input:"``)``console.log(string)``adjusted_s = balance_parenthesis(string)``console.log(``"Balanced Parenthesis: "``)``console.log(adjusted_s)` `// Code Contributed by Arushi Jindal.`

Output

```Input:
)))()
Balanced Parenthesis:
((()))()```

Time Complexity:  O(n), where n is size of String.

Auxiliary Space:  O(1).

## Method 2:

Approach:

• Let us assume that whenever we encounter with opening bracket the depth increases by one and with a closing bracket the depth decreases by one.
• Find the maximum negative depth in minDep and add that number of ‘(‘ at the beginning.
• Then loop the new sequence to find the number of ‘)’s needed at the end of the string and add them.
• Finally, return the string.

Below is the implementation of the approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Function to return balancedBrackets string``string balancedBrackets(string str)``{``    ``// Initializing dep to 0``    ``int` `dep = 0;` `    ``// Stores maximum negative depth``    ``int` `minDep = 0;` `    ``for` `(``int` `i = 0; i < str.length(); i++)``    ``{``        ``if` `(str[i] == ``'('``)``            ``dep++;``        ``else``            ``dep--;` `        ``// if dep is less than minDep``        ``if` `(minDep > dep)``            ``minDep = dep;``    ``}` `    ``// if minDep is less than 0 then there``    ``// is need to add '(' at the front``    ``if` `(minDep < 0)``    ``{``        ``for` `(``int` `i = 0; i < ``abs``(minDep); i++)``            ``str = ``'('` `+ str;``    ``}` `    ``// Reinitializing to check the updated string``    ``dep = 0;` `    ``for` `(``int` `i = 0; i < str.length(); i++)``    ``{``        ``if` `(str[i] == ``'('``)``            ``dep++;``        ``else``            ``dep--;``    ``}` `    ``// if dep is not 0 then there``    ``// is need to add ')' at the back``    ``if` `(dep != 0)``    ``{``        ``for` `(``int` `i = 0; i < dep; i++)``            ``str = str + ``')'``;``    ``}``    ``return` `str;``}` `// Driver code``int` `main()``{``    ``string str = ``")))()"``;``    ``cout << balancedBrackets(str);``}`

## Java

 `// Java implementation of the approach``import` `java.util.*;` `class` `GFG {` `    ``// Function to return balancedBrackets string``    ``static` `String balancedBrackets(String str)``    ``{``        ``// Initializing dep to 0``        ``int` `dep = ``0``;` `        ``// Stores maximum negative depth``        ``int` `minDep = ``0``;` `        ``for` `(``int` `i = ``0``; i < str.length(); i++)``        ``{``            ``if` `(str.charAt(i) == ``'('``)``                ``dep++;``            ``else``                ``dep--;` `            ``// if dep is less than minDep``            ``if` `(minDep > dep)``                ``minDep = dep;``        ``}` `        ``// if minDep is less than 0 then there``        ``// is need to add '(' at the front``        ``if` `(minDep < ``0``)``        ``{``            ``for` `(``int` `i = ``0``; i < Math.abs(minDep); i++)``                ``str = ``'('` `+ str;``        ``}` `        ``// Reinitializing to check the updated string``        ``dep = ``0``;` `        ``for` `(``int` `i = ``0``; i < str.length(); i++)``        ``{``            ``if` `(str.charAt(i) == ``'('``)``                ``dep++;``            ``else``                ``dep--;``        ``}` `        ``// if dep is not 0 then there``        ``// is need to add ')' at the back``        ``if` `(dep != ``0``)``        ``{``            ``for` `(``int` `i = ``0``; i < dep; i++)``                ``str = str + ``')'``;``        ``}``        ``return` `str;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``String str = ``")))()"``;``        ``System.out.println(balancedBrackets(str));``    ``}``}` `// This code is contributed by ihritik`

## Python3

 `# Python3 implementation of the approach` `# Function to return balancedBrackets String`  `def` `balancedBrackets(``Str``):` `    ``# Initializing dep to 0``    ``dep ``=` `0` `    ``# Stores maximum negative depth``    ``minDep ``=` `0` `    ``for` `i ``in` `Str``:``        ``if` `(i ``=``=` `'('``):``            ``dep ``+``=` `1``        ``else``:``            ``dep ``-``=` `1` `        ``# if dep is less than minDep``        ``if` `(minDep > dep):``            ``minDep ``=` `dep` `    ``# if minDep is less than 0 then there``    ``# is need to add '(' at the front``    ``if` `(minDep < ``0``):``        ``for` `i ``in` `range``(``abs``(minDep)):``            ``Str` `=` `'('` `+` `Str` `    ``# Reinitializing to check the updated String``    ``dep ``=` `0` `    ``for` `i ``in` `Str``:``        ``if` `(i ``=``=` `'('``):``            ``dep ``+``=` `1``        ``else``:``            ``dep ``-``=` `1` `    ``# if dep is not 0 then there``    ``# is need to add ')' at the back``    ``if` `(dep !``=` `0``):``        ``for` `i ``in` `range``(dep):``            ``Str` `=` `Str` `+` `')'` `    ``return` `Str`  `# Driver code``Str` `=` `")))()"``print``(balancedBrackets(``Str``))` `# This code is contributed by Mohit Kumar`

## C#

 `// C# implementation of the approach``using` `System;` `class` `GFG {` `    ``// Function to return balancedBrackets string``    ``static` `string` `balancedBrackets(``string` `str)``    ``{``        ``// Initializing dep to 0``        ``int` `dep = 0;` `        ``// Stores maximum negative depth``        ``int` `minDep = 0;` `        ``for` `(``int` `i = 0; i < str.Length; i++)``        ``{``            ``if` `(str[i] == ``'('``)``                ``dep++;``            ``else``                ``dep--;` `            ``// if dep is less than minDep``            ``if` `(minDep > dep)``                ``minDep = dep;``        ``}` `        ``// if minDep is less than 0 then there``        ``// is need to add '(' at the front``        ``if` `(minDep < 0)``        ``{``            ``for` `(``int` `i = 0; i < Math.Abs(minDep); i++)``                ``str = ``'('` `+ str;``        ``}` `        ``// Reinitializing to check the updated string``        ``dep = 0;` `        ``for` `(``int` `i = 0; i < str.Length; i++)``        ``{``            ``if` `(str[i] == ``'('``)``                ``dep++;``            ``else``                ``dep--;``        ``}` `        ``// if dep is not 0 then there``        ``// is need to add ')' at the back``        ``if` `(dep != 0)``        ``{``            ``for` `(``int` `i = 0; i < dep; i++)``                ``str = str + ``')'``;``        ``}``        ``return` `str;``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``String str = ``")))()"``;``        ``Console.WriteLine(balancedBrackets(str));``    ``}``}` `// This code is contributed by ihritik`

## Javascript

 ``

Output

`((()))()`

Time Complexity: O(N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up