Skip to content
Related Articles

Related Articles

Balanced expression with replacement

View Discussion
Improve Article
Save Article
  • Difficulty Level : Hard
  • Last Updated : 10 Aug, 2022
View Discussion
Improve Article
Save Article

Given a string that contains only the following => ‘{‘, ‘}’, ‘(‘, ‘)’, ‘[’, ‘]’. At some places there is ‘X’ in place of any bracket. Determine whether by replacing all ‘X’s with appropriate bracket, is it possible to make a valid bracket sequence.

Prerequisite: Balanced Parenthesis Expression

Examples: 

Input : S = "{(X[X])}"
Output : Balanced
The balanced expression after 
replacing X with suitable bracket is:
{([[]])}.

Input : [{X}(X)]
Output : Not balanced
No substitution of X with any bracket
results in a balanced expression.

Approach: We have discussed a solution on verifying whether given parenthesis expression is balanced or not

Following the same approach described in the article, a stack data structure is used for verifying whether given expression is balanced or not. For each type of character in string, the operations to be performed on stack are: 

  1. ‘{‘ or ‘(‘ or ‘[‘ : When current element of string is an opening bracket, push the element in stack.
  2. ‘}’ or ‘]’ or ‘)’ : When current element of string is a closing bracket, pop the top element of the stack and check if it is a matching opening bracket for the closing bracket or not. If it is matching, then move to next element of string. If it is not, then current string is not balanced. It is also possible that the element popped from stack is ‘X’. In that case ‘X’ is a matching opening bracket because it is pushed in stack only when it is assumed to be an opening bracket as described in next step.
  3. ‘X’ : When current element is X then it can either be a starting bracket or a closing bracket. First assume that it is a starting bracket and recursively call for next element by pushing X in stack. If the result of recursion is false then X is a closing bracket which matches the bracket at top of the stack (If stack is non-empty). So pop the top element and recursively call for next element. If the result of recursion is again false, then the expression is not balanced.

Also check for the case when stack is empty and current element is a closing bracket. In that case, the expression is not balanced.

Implementation: 

C++




// C++ program to determine whether given
// expression is balanced/ parenthesis
// expression or not.
#include <bits/stdc++.h>
using namespace std;
 
// Function to check if two brackets are matching
// or not.
int isMatching(char a, char b)
{
    if ((a == '{' && b == '}') || (a == '[' && b == ']')
        || (a == '(' && b == ')') || a == 'X')
        return 1;
    return 0;
}
 
// Recursive function to check if given expression
// is balanced or not.
int isBalanced(string s, stack<char> ele, int ind)
{
 
    // Base case.
    // If the string is balanced then all the opening
    // brackets had been popped and stack should be
    // empty after string is traversed completely.
    if (ind == s.length())
        return ele.empty();
 
    // variable to store element at the top of the stack.
    char topEle;
 
    // variable to store result of recursive call.
    int res;
 
    // Case 1: When current element is an opening bracket
    // then push that element in the stack.
    if (s[ind] == '{' || s[ind] == '(' || s[ind] == '[') {
        ele.push(s[ind]);
        return isBalanced(s, ele, ind + 1);
    }
 
    // Case 2: When current element is a closing bracket
    // then check for matching bracket at the top of the
    // stack.
    else if (s[ind] == '}' || s[ind] == ')' || s[ind] == ']') {
 
        // If stack is empty then there is no matching opening
        // bracket for current closing bracket and the
        // expression is not balanced.
        if (ele.empty())
            return 0;
 
        topEle = ele.top();
        ele.pop();
 
        // Check bracket is matching or not.
        if (!isMatching(topEle, s[ind]))
            return 0;
         
        return isBalanced(s, ele, ind + 1);
    }
 
    // Case 3: If current element is 'X' then check
    // for both the cases when 'X' could be opening
    // or closing bracket.
    else if (s[ind] == 'X') {
        stack<char> tmp = ele;
        tmp.push(s[ind]);
        res = isBalanced(s, tmp, ind + 1);
        if (res)
            return 1;
        if (ele.empty())
            return 0;
        ele.pop();
        return isBalanced(s, ele, ind + 1);
    }
}
 
int main()
{
    string s = "{(X}[]";
    stack<char> ele;
   
     //Check if the String is of even length
      if(s.length()%2==0){
        if (isBalanced(s, ele, 0))
            cout << "Balanced";   
        else
            cout << "Not Balanced";
    }
   
      // If the length of the string is not even
      // then it is not a balanced string
      else{
          cout << "Not Balanced";
      }
    return 0;
}

Java




// Java program to determine
// whether given expression
// is balanced/ parenthesis
// expression or not.
import java.util.Stack;
 
class GFG {
    // Function to check if two
    // brackets are matching or not.
 
    static int isMatching(char a,
            char b) {
        if ((a == '{' && b == '}')
                || (a == '[' && b == ']')
                || (a == '(' && b == ')') || a == 'X') {
            return 1;
        }
        return 0;
    }
 
    // Recursive function to
    // check if given expression
    // is balanced or not.
    static int isBalanced(String s,
            Stack<Character> ele,
            int ind) {
 
        // Base case.
        // If the string is balanced
        // then all the opening brackets
        // had been popped and stack
        // should be empty after string
        // is traversed completely.
        if (ind == s.length()) {
            if (ele.size() == 0) {
                return 1;
            } else {
                return 0;
            }
        }
 
        // variable to store element
        // at the top of the stack.
        char topEle;
 
        // variable to store result
        // of recursive call.
        int res;
 
        // Case 1: When current element
        // is an opening bracket
        // then push that element
        // in the stack.
        if (s.charAt(ind) == '{'
                || s.charAt(ind) == '('
                || s.charAt(ind) == '[') {
            ele.push(s.charAt(ind));
            return isBalanced(s, ele, ind + 1);
        } // Case 2: When current element
        // is a closing bracket then
        // check for matching bracket
        // at the top of the stack.
        else if (s.charAt(ind) == '}'
                || s.charAt(ind) == ')'
                || s.charAt(ind) == ']') {
 
            // If stack is empty then there
            // is no matching opening bracket
            // for current closing bracket and
            // the expression is not balanced.
            if (ele.size() == 0) {
                return 0;
            }
 
            topEle = ele.peek();
            ele.pop();
 
            // Check bracket is
            // matching or not.
            if (isMatching(topEle, s.charAt(ind)) == 0) {
                return 0;
            }
 
            return isBalanced(s, ele, ind + 1);
        } // Case 3: If current element
        // is 'X' then check for both
        // the cases when 'X' could be
        // opening or closing bracket.
        else if (s.charAt(ind) == 'X') {
            Stack<Character> tmp = new Stack<>();
            //because in java, direct assignment copies only reference and not the whole object
            tmp.addAll(ele);
            tmp.push(s.charAt(ind));
            res = isBalanced(s, tmp, ind + 1);
            if (res == 1) {
                return 1;
            }
            if (ele.size() == 0) {
                return 0;
            }
            ele.pop();
            return isBalanced(s, ele, ind + 1);
        }
        return 1;
    }
 
    // Driver Code
    public static void main(String[] args) {
 
        String s = "{(X}[]";
        Stack<Character> ele = new Stack<Character>();
       
          // Check if the given string is of even length
        if(s.length()%2==0){
            if (isBalanced(s, ele, 0) != 0) {
                System.out.println("Balanced");
            } else {
                System.out.println("Not Balanced");
            }
        }
       
        // If the length of the string is not even
          // then it is not a balanced string
          else{
            System.out.println("Not Balanced");
        }
    }
}

Python3




# Python3 program to determine whether
# given expression is balanced/ parenthesis
# expression or not.
 
# Function to check if two brackets are
# matching or not.
def isMatching(a, b):
     
    if ((a == '{' and b == '}') or
        (a == '[' and b == ']') or
        (a == '(' and b == ')') or
         a == 'X'):
        return 1
         
    return 0
 
# Recursive function to check if given
# expression is balanced or not.
def isBalanced(s, ele, ind):
     
    # Base case.
    # If the string is balanced then all the
    # opening brackets had been popped and
    # stack should be empty after string is
    # traversed completely.
    if (ind == len(s)):
        if len(ele) == 0:
            return True
        else:
            return False
 
    # Variable to store element at the top
    # of the stack.
    # char topEle;
 
    # Variable to store result of
    # recursive call.
    # int res;
 
    # Case 1: When current element is an
    # opening bracket then push that
    # element in the stack.
    if (s[ind] == '{' or s[ind] == '(' or
        s[ind] == '['):
        ele.append(s[ind])
        return isBalanced(s, ele, ind + 1)
 
    # Case 2: When current element is a closing
    # bracket then check for matching bracket
    # at the top of the stack.
    elif (s[ind] == '}' or s[ind] == ')' or
          s[ind] == ']'):
 
        # If stack is empty then there is no matching
        # opening bracket for current closing bracket
        # and the expression is not balanced.
        if (len(ele) == 0):
            return 0
 
        topEle = ele[-1]
        ele.pop()
 
        # Check bracket is matching or not.
        if (isMatching(topEle, s[ind]) == 0):
            return 0
         
        return isBalanced(s, ele, ind + 1)
 
    # Case 3: If current element is 'X' then check
    # for both the cases when 'X' could be opening
    # or closing bracket.
    elif (s[ind] == 'X'):
        tmp = ele
        tmp.append(s[ind])
        res = isBalanced(s, tmp, ind + 1)
         
        if (res):
            return 1
        if (len(ele) == 0):
            return 0
             
        ele.pop()
         
        return isBalanced(s, ele, ind + 1)
         
# Driver Code
s = "{(X}[]"
ele = []
 
# Check if the length of the given string is even
if(len(s)%2==0):
    if (isBalanced(s, ele, 0)): print("Balanced")
    else: print("Not Balanced")
     
# If the length is not even, then the string is not balanced
else: print("Not Balanced")
 
# This code is contributed by divyeshrabadiya07

C#




// C# program to determine
// whether given expression
// is balanced/ parenthesis
// expression or not.
using System;
using System.Collections.Generic;
 
class GFG
{
    // Function to check if two
    // brackets are matching or not.
    static int isMatching(char a,
                          char b)
    {
        if ((a == '{' && b == '}') ||
            (a == '[' && b == ']') ||
            (a == '(' && b == ')') || a == 'X')
            return 1;
        return 0;
    }
     
    // Recursive function to
    // check if given expression
    // is balanced or not.
    static int isBalanced(string s,
                          Stack<char> ele,
                          int ind)
    {
     
        // Base case.
        // If the string is balanced
        // then all the opening brackets
        // had been popped and stack
        // should be empty after string
        // is traversed completely.
        if (ind == s.Length)
        {
            if (ele.Count == 0)
                return 1;
            else
                return 0;
        }
     
        // variable to store element
        // at the top of the stack.
        char topEle;
     
        // variable to store result
        // of recursive call.
        int res;
     
        // Case 1: When current element
        // is an opening bracket
        // then push that element
        // in the stack.
        if (s[ind] == '{' ||
            s[ind] == '(' ||
            s[ind] == '[')
        {
            ele.Push(s[ind]);
            return isBalanced(s, ele, ind + 1);
        }
     
        // Case 2: When current element
        // is a closing bracket then
        // check for matching bracket
        // at the top of the stack.
        else if (s[ind] == '}' ||
                 s[ind] == ')' ||
                 s[ind] == ']')
        {
     
            // If stack is empty then there
            // is no matching opening bracket
            // for current closing bracket and
            // the expression is not balanced.
            if (ele.Count == 0)
                return 0;
     
            topEle = ele.Peek();
            ele.Pop();
     
            // Check bracket is
            // matching or not.
            if (isMatching(topEle, s[ind]) == 0)
                return 0;
             
            return isBalanced(s, ele, ind + 1);
        }
     
        // Case 3: If current element
        // is 'X' then check for both
        // the cases when 'X' could be
        // opening or closing bracket.
        else if (s[ind] == 'X')
        {
            Stack<char> tmp = ele;
            tmp.Push(s[ind]);
            res = isBalanced(s, tmp, ind + 1);
            if (res == 1)
                return 1;
            if (ele.Count == 0)
                return 0;
            ele.Pop();
            return isBalanced(s, ele, ind + 1);
        }
        return 1;
    }
     
    // Driver Code
    static void Main()
    {
        string s = "{(X}[]";
        Stack<char> ele = new Stack<char>();
       
        // Check if the String is of even length
          if(s.Length%2==0){
        if (isBalanced(s, ele, 0) != 0)
            Console.Write("Balanced");
        else
            Console.Write("Not Balanced");
        }
          // If the length of the string is not even
          // then it is not a balanced string
      else{
          Console.Write("Not Balanced");
      }
    }
}
 
// This code is contributed by
// Manish Shaw(manishshaw1)

Javascript




<script>
 
// JavaScript program to determine whether given
// expression is balanced/ parenthesis
// expression or not.
 
// Function to check if two brackets are matching
// or not.
function isMatching(a, b)
{
    if ((a == '{' && b == '}') || (a == '[' && b == ']')
        || (a == '(' && b == ')') || a == 'X')
        return 1;
    return 0;
}
 
// Recursive function to check if given expression
// is balanced or not.
function isBalanced(s, ele, ind)
{
 
    // Base case.
    // If the string is balanced then all the opening
    // brackets had been popped and stack should be
    // empty after string is traversed completely.
    if (ind == s.length)
        return ele.length==0;
 
    // variable to store element at the top of the stack.
    var topEle;
 
    // variable to store result of recursive call.
    var res;
 
    // Case 1: When current element is an opening bracket
    // then push that element in the stack.
    if (s[ind] == '{' || s[ind] == '(' || s[ind] == '[') {
        ele.push(s[ind]);
        return isBalanced(s, ele, ind + 1);
    }
 
    // Case 2: When current element is a closing bracket
    // then check for matching bracket at the top of the
    // stack.
    else if (s[ind] == '}' || s[ind] == ')' || s[ind] == ']') {
 
        // If stack is empty then there is no matching opening
        // bracket for current closing bracket and the
        // expression is not balanced.
        if (ele.length==0)
            return 0;
 
        topEle = ele[ele.length-1];
        ele.pop();
 
        // Check bracket is matching or not.
        if (!isMatching(topEle, s[ind]))
            return 0;
         
        return isBalanced(s, ele, ind + 1);
    }
 
    // Case 3: If current element is 'X' then check
    // for both the cases when 'X' could be opening
    // or closing bracket.
    else if (s[ind] == 'X') {
        var tmp = ele;
        tmp.push(s[ind]);
        res = isBalanced(s, tmp, ind + 1);
        if (res)
            return 1;
        if (ele.length==0)
            return 0;
        ele.pop();
        return isBalanced(s, ele, ind + 1);
    }
}
 
var s = "{(X}[]";
var ele = [];
if (isBalanced(s, ele, 0))
    document.write( "Balanced");   
else
    document.write( "Not Balanced");   
 
 
</script>

Output

Balanced

Time Complexity: O((2^n)*n) 
Auxiliary Space: O(N)


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!