Open In App
Related Articles

# Expression contains redundant bracket or not

Given a string of balanced expressions, find if it contains a redundant parenthesis or not. A set of parenthesis is redundant if the same sub-expression is surrounded by unnecessary or multiple brackets. Print ‘Yes‘ if redundant, else ‘No‘.

Note: Expression may contain ‘+‘, ‘*‘, ‘‘ and ‘/‘ operators. Given expression is valid and there are no white spaces present.

Examples:

Input: str = “((a+b))”
Output: YES
Explanation: ((a+b)) can reduced to (a+b), this Redundant

Input: str = “(a+(b)/c)”
Output: YES
Explanation: (a+(b)/c) can reduced to (a+b/c) because b is surrounded by () which is redundant.

## Checking Redundant Bracket using Stack

The idea is to use the stack, For any sub-expression of expression, if we are able to pick any sub-expression of expression surrounded by (), then we are again left with ( ) as part of the string, we have redundant braces.

Follow the steps mentioned below to implement the approach:

• We iterate through the given expression and for each character in the expression
• if the character is an open parenthesis ‘(‘ or any of the operators or operands, we push it to the stack.
• If the character is close parenthesis ‘)’, then pop characters from the stack till matching open parenthesis ‘(‘ is found.
• Now for redundancy two conditions will arise while popping.
• If immediate pop hits an open parenthesis ‘(‘, then we have found a duplicate parenthesis. For example, (((a+b))+c) has duplicate brackets around a+b. When we reach the second “)” after a+b, we have “((” in the stack. Since the top of the stack is an opening bracket, we conclude that there are duplicate brackets.
• If immediate pop doesn’t hit any operand(‘*’, ‘+’, ‘/’, ‘-‘) then it indicates the presence of unwanted brackets surrounded by expression. For instance, (a)+b contains unwanted () around a thus it is redundant.

Below is the implementation of the above approach:

## C++

 /* C++ Program to check whether valid expression is redundant or not*/#include using namespace std; // Function to check redundant brackets in a// balanced expressionbool checkRedundancy(string& str){    // create a stack of characters    stack st;     // Iterate through the given expression    for (auto& ch : str) {         // if current character is close parenthesis ')'        if (ch == ')') {            char top = st.top();            st.pop();             // If immediate pop have open parenthesis '('            // duplicate brackets found            bool flag = true;             while (!st.empty() and top != '(') {                 // Check for operators in expression                if (top == '+' || top == '-' ||                    top == '*' || top == '/')                    flag = false;                 // Fetch top element of stack                top = st.top();                st.pop();            }             // If operators not found            if (flag == true)                return true;        }         else            st.push(ch); // push open parenthesis '(',                  // operators and operands to stack    }    return false;} // Function to check redundant bracketsvoid findRedundant(string& str){    bool ans = checkRedundancy(str);    if (ans == true)        cout << "Yes\n";    else        cout << "No\n";} // Driver codeint main(){    string str = "((a+b))";    findRedundant(str);    return 0;}

## Java

 /* Java Program to check whether validexpression is redundant or not*/import java.util.Stack;public class GFG {// Function to check redundant brackets in a// balanced expression     static boolean checkRedundancy(String s) {        // create a stack of characters        Stack st = new Stack<>();        char[] str = s.toCharArray();        // Iterate through the given expression        for (char ch : str) {             // if current character is close parenthesis ')'            if (ch == ')') {                char top = st.peek();                st.pop();                 // If immediate pop have open parenthesis '('                // duplicate brackets found                boolean flag = true;                 while (top != '(') {                     // Check for operators in expression                    if (top == '+' || top == '-'                            || top == '*' || top == '/') {                        flag = false;                    }                     // Fetch top element of stack                    top = st.peek();                    st.pop();                }                 // If operators not found                if (flag == true) {                    return true;                }            } else {                st.push(ch); // push open parenthesis '(',            }                // operators and operands to stack        }        return false;    } // Function to check redundant brackets    static void findRedundant(String str) {        boolean ans = checkRedundancy(str);        if (ans == true) {            System.out.println("Yes");        } else {            System.out.println("No");        }    } // Driver code    public static void main(String[] args) {        String str = "((a+b))";        findRedundant(str);     }}

## Python3

 # Python3 Program to check whether valid# expression is redundant or not # Function to check redundant brackets# in a balanced expressiondef checkRedundancy(Str):         # create a stack of characters    st = []     # Iterate through the given expression    for ch in Str:         # if current character is close        # parenthesis ')'        if (ch == ')'):            top = st[-1]            st.pop()             # If immediate pop have open parenthesis            # '(' duplicate brackets found            flag = True             while (top != '('):                 # Check for operators in expression                if (top == '+' or top == '-' or                    top == '*' or top == '/'):                    flag = False                 # Fetch top element of stack                top = st[-1]                st.pop()             # If operators not found            if (flag == True):                return True         else:            st.append(ch) # append open parenthesis '(',                          # operators and operands to stack    return False # Function to check redundant bracketsdef findRedundant(Str):    ans = checkRedundancy(Str)    if (ans == True):        print("Yes")    else:        print("No") # Driver codeif __name__ == '__main__':    Str = "((a+b))"    findRedundant(Str)  # This code is contributed by PranchalK

## C#

 /* C# Program to check whether validexpression is redundant or not*/using System;using System.Collections.Generic; class GFG{    // Function to check redundant brackets in a    // balanced expression    static bool checkRedundancy(String s)    {        // create a stack of characters        Stack st = new Stack();        char[] str = s.ToCharArray();                 // Iterate through the given expression        foreach (char ch in str)        {             // if current character is close parenthesis ')'            if (ch == ')')            {                char top = st.Peek();                st.Pop();                 // If immediate pop have open parenthesis '('                // duplicate brackets found                bool flag = true;                 while (top != '(')                {                     // Check for operators in expression                    if (top == '+' || top == '-'                            || top == '*' || top == '/')                    {                        flag = false;                    }                     // Fetch top element of stack                    top = st.Peek();                    st.Pop();                }                 // If operators not found                if (flag == true)                {                    return true;                }            }            else            {                st.Push(ch); // push open parenthesis '(',            }         // operators and operands to stack        }        return false;    }     // Function to check redundant brackets    static void findRedundant(String str)    {        bool ans = checkRedundancy(str);        if (ans == true)        {            Console.WriteLine("Yes");        }        else        {            Console.WriteLine("No");        }    }     // Driver code    public static void Main(String[] args)    {        String str = "((a+b))";        findRedundant(str);    }} /* This code contributed by PrinciRaj1992 */

## Javascript



Output

Yes

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