 Open in App
Not now

# Expression contains redundant bracket or not

• Difficulty Level : Medium
• Last Updated : 22 Aug, 2022

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 expression` `bool` `checkRedundancy(string& str)` `{` `    ``// create a stack of characters` `    ``stack<``char``> 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 brackets` `void` `findRedundant(string& str)` `{` `    ``bool` `ans = checkRedundancy(str);` `    ``if` `(ans == ``true``)` `        ``cout << ``"Yes\n"``;` `    ``else` `        ``cout << ``"No\n"``;` `}`   `// Driver code` `int` `main()` `{` `    ``string str = ``"((a+b))"``;` `    ``findRedundant(str);` `    ``return` `0;` `}`

## Java

 `/* Java Program to check whether valid ` `expression 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 expression ` `def` `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 brackets ` `def` `findRedundant(``Str``):` `    ``ans ``=` `checkRedundancy(``Str``) ` `    ``if` `(ans ``=``=` `True``): ` `        ``print``(``"Yes"``) ` `    ``else``:` `        ``print``(``"No"``)`   `# Driver code ` `if` `__name__ ``=``=` `'__main__'``:` `    ``Str` `=` `"((a+b))"` `    ``findRedundant(``Str``) `     `# This code is contributed by PranchalK`

## C#

 `/* C# Program to check whether valid ` `expression 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<``char``> st = ``new` `Stack<``char``>();` `        ``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)

My Personal Notes arrow_drop_up
Related Articles