Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Check if the bracket sequence can be balanced with at most one change in the position of a bracket

  • Difficulty Level : Easy
  • Last Updated : 26 Jul, 2021

Given an unbalanced bracket sequence as a string str, the task is to find whether the given string can be balanced by moving at most one bracket from its original place in the sequence to any other position.
Examples: 
 

Input: str = “)(()” 
Output: Yes 
As by moving s[0] to the end will make it valid. 
“(())”
Input: str = “()))(()” 
Output: No 
 

 

Approach: Consider X as a valid bracket then definitely (X) is also valid. If X is not valid and can be balanced with just one change of position in some bracket then it must be of type X = “)(“ where ‘)’ has been placed before ‘(‘. 
Now, X can be replaced with (X) as it will not affect the balanced nature of X. The new string becomes X = “()()” which is balanced. 
Hence, if (X) is balanced then we can say that X can be balanced with at most one change in the position of some bracket.
Below is the implementation of the above approach:
 

C++




// CPP implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function that returns true if the sequence
// can be balanced by changing the
// position of at most one bracket
bool canBeBalanced(string s, int n)
{
    // Odd length string can
    // never be balanced
    if (n % 2 == 1)
        return false;
 
    // Add '(' in the beginning and ')'
    // in the end of the string
    string k = "(";
    k += s + ")";
 
    vector<string> d;
    int cnt = 0;
 
    for (int i = 0; i < k.length(); i++)
    {
        // If its an opening bracket then
        // append it to the temp string
        if (k[i] == '(')
            d.push_back("(");
 
        // If its a closing bracket
        else
        {
            // There was an opening bracket
            // to match it with
            if (d.size() != 0)
                d.pop_back();
 
            // No opening bracket to
            // match it with
            else
                return false;
        }
    }
 
    // Sequence is balanced
    if (d.empty())
        return true;
    return false;
}
 
// Driver Code
int main(int argc, char const *argv[])
{
    string s = ")(()";
    int n = s.length();
 
    (canBeBalanced(s, n)) ? cout << "Yes"
                  << endl : cout << "No" << endl;
    return 0;
}
 
// This code is contributed by
// sanjeev2552
Java



// Java implementation of the approach
import java.util.Vector;
 
class GFG
{
 
    // Function that returns true if the sequence
    // can be balanced by changing the
    // position of at most one bracket
    static boolean canBeBalanced(String s, int n)
    {
 
        // Odd length string can
        // never be balanced
        if (n % 2 == 1)
            return false;
 
        // Add '(' in the beginning and ')'
        // in the end of the string
        String k = "(";
        k += s + ")";
        Vector<String> d = new Vector<>();
 
        for (int i = 0; i < k.length(); i++)
        {
 
            // If its an opening bracket then
            // append it to the temp string
            if (k.charAt(i) == '(')
                d.add("(");
 
            // If its a closing bracket
            else
            {
 
                // There was an opening bracket
                // to match it with
                if (d.size() != 0)
                    d.remove(d.size() - 1);
 
                // No opening bracket to
                // match it with
                else
                    return false;
            }
        }
 
        // Sequence is balanced
        if (d.isEmpty())
            return true;
        return false;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        String s = ")(()";
        int n = s.length();
 
        if (canBeBalanced(s, n))
            System.out.println("Yes");
        else
            System.out.println("No");
    }
}
 
// This code is contributed by
// sanjeev2552
Python3



# Python3 implementation of the approach
 
# Function that returns true if the sequence
# can be balanced by changing the
# position of at most one bracket
def canBeBalanced(s, n):
 
    # Odd length string can
    # never be balanced
    if n % 2 == 1:
        return False
 
    # Add '(' in the beginning and ')'
    # in the end of the string
    k = "("
    k = k + s+")"
    d = []
    count = 0
    for i in range(len(k)):
 
        # If its an opening bracket then
        # append it to the temp string
        if k[i] == "(":
            d.append("(")
 
        # If its a closing bracket
        else:
 
            # There was an opening bracket
            # to match it with
            if len(d)!= 0:
                d.pop()
 
            # No opening bracket to
            # match it with
            else:
                return False
     
    # Sequence is balanced
    if len(d) == 0:
        return True
    return False
 
# Driver code
S = ")(()"
n = len(S)
if(canBeBalanced(S, n)):
    print("Yes")
else:
    print("No")
C#



// C# implementation of the approach
using System;
using System.Collections.Generic;
 
class GFG
{
 
    // Function that returns true if the sequence
    // can be balanced by changing the
    // position of at most one bracket
    static bool canBeBalanced(string s, int n)
    {
 
        // Odd length string can
        // never be balanced
        if (n % 2 == 1)
            return false;
 
        // Add '(' in the beginning and ')'
        // in the end of the string
        string k = "(";
        k += s + ")";
        List<string> d = new List<string>();
 
        for (int i = 0; i < k.Length; i++)
        {
 
            // If its an opening bracket then
            // append it to the temp string
            if (k[i] == '(')
                d.Add("(");
 
            // If its a closing bracket
            else
            {
 
                // There was an opening bracket
                // to match it with
                if (d.Count != 0)
                    d.RemoveAt(d.Count - 1);
 
                // No opening bracket to
                // match it with
                else
                    return false;
            }
        }
 
        // Sequence is balanced
        if (d.Count == 0)
            return true;
        return false;
    }
 
    // Driver Code
    public static void Main()
    {
        string s = ")(()";
        int n = s.Length;
 
        if (canBeBalanced(s, n))
            Console.Write("Yes");
        else
            Console.Write("No");
    }
}
 
// This code is contributed by
// mohit kumar 29
Javascript



<script>
 
// JavaScript implementation of the approach
 
// Function that returns true if the sequence
    // can be balanced by changing the
    // position of at most one bracket
function canBeBalanced(s,n)
{
    // Odd length string can
        // never be balanced
        if (n % 2 == 1)
            return false;
   
        // Add '(' in the beginning and ')'
        // in the end of the string
        let k = "(";
        k += s + ")";
        let d = [];
   
        for (let i = 0; i < k.length; i++)
        {
   
            // If its an opening bracket then
            // append it to the temp string
            if (k[i] == '(')
                d.push("(");
   
            // If its a closing bracket
            else
            {
   
                // There was an opening bracket
                // to match it with
                if (d.length != 0)
                    d.pop();
   
                // No opening bracket to
                // match it with
                else
                    return false;
            }
        }
   
        // Sequence is balanced
        if (d.length==0)
            return true;
        return false;
}
 
// Driver Code
let s = ")(()";
        let n = s.length;
   
        if (canBeBalanced(s, n))
            document.write("Yes");
        else
            document.write("No");
 
 
// This code is contributed by unknown2108
 
</script>
Output: 
Yes
 

My Personal Notes
arrow_drop_up
Next

Check for Balanced Brackets in an expression (well-formedness) using Stack
Recommended Articles
Page :
Check if a given string can be converted to a Balanced Bracket Sequence
07, Jan 21
Convert an unbalanced bracket sequence to a balanced sequence
19, Aug 19
Maximum Pairs of Bracket Sequences which can be concatenated to form a Regular Bracket Sequence
07, Jul 21
Find the lexicographical next balanced bracket sequence
29, May 19
Minimum Cost required to generate a balanced Bracket Sequence
21, Aug 20
Minimize cost to rearrange substrings to convert a string to a Balanced Bracket Sequence
14, Jan 21
Check if a Regular Bracket Sequence can be formed with concatenation of given strings
20, Sep 21
Find index of closing bracket for a given opening bracket in an expression
23, Nov 17
Number of balanced bracket subsequence of length 2 and 4
17, Oct 18
Minimum number of bracket reversals needed to make an expression balanced | Set - 2
05, Mar 19
Print the balanced bracket expression using given brackets
08, Mar 19
Minimum number of bracket reversals needed to make an expression balanced
27, Oct 15
Check if it is possible to obtain a Balanced Parenthesis by shifting brackets to either end at most K times
14, Apr 21
Check if two non-duplicate strings can be made equal after at most two swaps in one string
14, Dec 21
Number of closing brackets needed to complete a regular bracket sequence
15, Nov 18
InfyTQ 2019 : Find the position from where the parenthesis is not balanced
30, Jul 19
Maximum possible balanced binary substring splits with at most cost K
18, Nov 21
Print all Balanced Brackets Strings that can be formed by replacing wild card '?'
28, Oct 21
Check if expression contains redundant bracket or not | Set 2
30, Aug 19
Find the Kth position element of the given sequence
29, Oct 19
Check if X can give change to every person in the Queue
25, Jun 18
Find a valid parenthesis sequence of length K from a given valid parenthesis sequence
10, Sep 20
Check if a string can be formed from another string by at most X circular clockwise shifts
10, May 20
Check if given Strings can be made equal by inserting at most 1 String
23, Jun 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
divyamohan123
@divyamohan123
Vote for difficulty
Current difficulty :
Easy





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!