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 <bits/stdc++.h> 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<Character> stack = new Stack<Character>(); // 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. |
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 <bits/stdc++.h> 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
<script> // JavaScript implementation of the approach // Function to return balancedBrackets string function balancedBrackets(str) { // Initializing dep to 0 var dep = 0; // Stores maximum negative depth var minDep = 0; for ( var 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 ( var i = 0; i < Math.abs(minDep); i++) str = "(" + str; } // Reinitializing to check the updated string dep = 0; for ( var 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 ( var i = 0; i < dep; i++) str = str + ")" ; } return str; } // Driver code var str = ")))()" ; document.write(balancedBrackets(str)); </script> |
((()))()
Time Complexity: O(N)
Auxiliary Space: O(1)
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!