Open in App
Not now

# Remove brackets from an algebraic string containing + and – operators

• Difficulty Level : Medium
• Last Updated : 14 Dec, 2022

Simplify a given algebraic string of characters, ‘+’, ‘-‘ operators and parentheses. Output the simplified string without parentheses.

Examples:

```Input : "(a-(b+c)+d)"
Output : "a-b-c+d"

Input : "a-(b-c-(d+e))-f"
Output : "a-b+c+d+e-f" ```

The idea is to check operators just before starting of bracket, i.e., before character ‘(‘. If operator is -, we need to toggle all operators inside the bracket. A stack is used which stores only two integers 0 and 1 to indicate whether to toggle or not.

We iterate for every character of input string. Initially push 0 to stack. Whenever the character is an operator (‘+’ or ‘-‘), check top of stack. If top of stack is 0, append the same operator in the resultant string. If top of stack is 1, append the other operator (if ‘+’ append ‘-‘) in the resultant string.

Implementation:

## C++

 `// C++ program to simplify algebraic string` `#include ` `using` `namespace` `std;`   `// Function to simplify the string` `char``* simplify(string str)` `{` `    ``int` `len = str.length();`   `    ``// resultant string of max length equal` `    ``// to length of input string` `    ``char``* res = ``new` `char``(len);` `    ``int` `index = 0, i = 0;`   `    ``// create empty stack` `    ``stack<``int``> s;` `    ``s.push(0);`   `    ``while` `(i < len) {` `          ``// Don't do any operation` `        ``if``(str[i] == ``'('` `&& i == 0) {` `            ``i++;` `              ``continue``;` `        ``}` `      `  `        ``if` `(str[i] == ``'+'``) {`   `            ``// If top is 1, flip the operator` `            ``if` `(s.top() == 1)` `                ``res[index++] = ``'-'``;`   `            ``// If top is 0, append the same operator` `            ``if` `(s.top() == 0)` `                ``res[index++] = ``'+'``;`   `        ``} ``else` `if` `(str[i] == ``'-'``) {` `            ``if` `(s.top() == 1) {` `                  ``if``(res[index-1] == ``'+'` `|| res[index-1] == ``'-'``) res[index-1] = ``'+'``; ``// Overriding previous sign ` `                ``else` `res[index++] = ``'+'``;` `            ``}` `            ``else` `if` `(s.top() == 0) {` `                  ``if``(res[index-1] == ``'+'` `|| res[index-1] == ``'-'``) res[index-1] = ``'-'``; ``// Overriding previous sign` `                ``else` `res[index++] = ``'-'``; ` `            ``}` `        ``} ``else` `if` `(str[i] == ``'('` `&& i > 0) {` `            ``if` `(str[i - 1] == ``'-'``) {`   `                ``// x is opposite to the top of stack` `                ``int` `x = (s.top() == 1) ? 0 : 1;` `                ``s.push(x);` `            ``}`   `            ``// push value equal to top of the stack` `            ``else` `if` `(str[i - 1] == ``'+'``)` `                ``s.push(s.top());` `        ``}`   `        ``// If closing parentheses pop the stack once` `        ``else` `if` `(str[i] == ``')'``)` `            ``s.pop();`   `        ``// copy the character to the result` `        ``else` `            ``res[index++] = str[i];` `        ``i++;` `    ``}` `    ``return` `res;` `}`   `// Driver program` `int` `main()` `{` `    ``string s1 = ``"(a-(b+c)+d)"``;` `    ``string s2 = ``"a-(b-c-(d+e))-f"``;` `    ``cout << simplify(s1) << endl;` `    ``cout << simplify(s2) << endl;` `    ``return` `0;` `}`

## Java

 `// Java program to simplify algebraic string` `import` `java.util.*;` `class` `GfG { `   `// Function to simplify the string ` `static` `String simplify(String str) ` `{ ` `    ``int` `len = str.length(); `   `    ``// resultant string of max length equal ` `    ``// to length of input string ` `    ``char` `res[] = ``new` `char``[len]; ` `    ``int` `index = ``0``, i = ``0``; `   `    ``// create empty stack ` `    ``Stack s = ``new` `Stack (); ` `    ``s.push(``0``); `   `    ``while` `(i < len) { ` `          ``// Don't do any operation` `        ``if``(str.charAt(i) == ``'('` `&& i == ``0``) {` `            ``i++;` `              ``continue``;` `        ``}` `      `  `        ``if` `(str.charAt(i) == ``'+'``) { `   `            ``// If top is 1, flip the operator ` `            ``if` `(s.peek() == ``1``) ` `                ``res[index++] = ``'-'``; `   `            ``// If top is 0, append the same operator ` `            ``if` `(s.peek() == ``0``) ` `                ``res[index++] = ``'+'``; `   `        ``} ``else` `if` `(str.charAt(i) == ``'-'``) { ` `            ``if` `(s.peek() == ``1``) ` `                ``res[index++] = ``'+'``; ` `            ``else` `if` `(s.peek() == ``0``) ` `                ``res[index++] = ``'-'``; ` `        ``} ``else` `if` `(str.charAt(i) == ``'('` `&& i > ``0``) { ` `            ``if` `(str.charAt(i - ``1``) == ``'-'``) { `   `                ``// x is opposite to the top of stack ` `                ``int` `x = (s.peek() == ``1``) ? ``0` `: ``1``; ` `                ``s.push(x); ` `            ``} `   `            ``// push value equal to top of the stack ` `            ``else` `if` `(str.charAt(i - ``1``) == ``'+'``) ` `                ``s.push(s.peek()); ` `        ``} `   `        ``// If closing parentheses pop the stack once ` `        ``else` `if` `(str.charAt(i) == ``')'``) ` `            ``s.pop(); ` `              `  `        ``else` `if``(str.charAt(i) == ``'('` `&& i == ``0``)` `              ``i = ``0``;` `        ``// copy the character to the result ` `          ``else` `            ``res[index++] = str.charAt(i); ` `        ``i++; ` `    ``} ` `    ``return` `new` `String(res); ` `} `   `// Driver program ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``String s1 = ``"(a-(b+c)+d)"``; ` `    ``String s2 = ``"a-(b-c-(d+e))-f"``; ` `    ``System.out.println(simplify(s1)); ` `    ``System.out.println(simplify(s2));` `}` `} `

## Python3

 `# Python3 program to simplify algebraic String`   `# Function to simplify the String`     `def` `simplify(``Str``):` `    ``Len` `=` `len``(``Str``)`   `    ``# resultant String of max Length` `    ``# equal to Length of input String` `    ``res ``=` `[``None``] ``*` `Len` `    ``index ``=` `0` `    ``i ``=` `0`   `    ``# create empty stack` `    ``s ``=` `[]` `    ``s.append(``0``)`   `    ``while` `(i < ``Len``):` `          ``if` `(``Str``[i] ``=``=` `'('` `and` `i ``=``=` `0``): ` `                ``i ``+``=` `1` `                ``continue`   `        ``if` `(``Str``[i] ``=``=` `'+'``):`   `            ``# If top is 1, flip the operator ` `            ``if` `(s[``-``1``] ``=``=` `1``): ` `                ``res[index] ``=` `'-'` `                ``index ``+``=` `1`   `            ``# If top is 0, append the ` `            ``# same operator ` `            ``if` `(s[``-``1``] ``=``=` `0``):` `                ``res[index] ``=` `'+'` `                ``index ``+``=` `1`   `        ``else` `if` `(``Str``[i] ``=``=` `'-'``):` `            ``if` `(s[``-``1``] ``=``=` `1``): ` `                ``res[index] ``=` `'+'` `                ``index ``+``=` `1` `            ``else` `if` `(s[``-``1``] ``=``=` `0``): ` `                ``res[index] ``=` `'-'` `                ``index ``+``=` `1` `        ``else` `if` `(``Str``[i] ``=``=` `'('` `and` `i > ``0``):` `            ``if` `(``Str``[i ``-` `1``] ``=``=` `'-'``):`   `                ``# x is opposite to the top of stack ` `                ``x ``=` `0` `if` `(s[``-``1``] ``=``=` `1``) ``else` `1` `                ``s.append(x)`   `            ``# append value equal to top of the stack ` `            ``else` `if` `(``Str``[i ``-` `1``] ``=``=` `'+'``): ` `                ``s.append(s[``-``1``])`   `        ``# If closing parentheses pop` `        ``# the stack once ` `        ``else` `if` `(``Str``[i] ``=``=` `')'``): ` `            ``s.pop() `   `        ``# copy the character to the result ` `        ``else``:` `            ``res[index] ``=` `Str``[i]` `            ``index ``+``=` `1` `        ``i ``+``=` `1` `    ``return` `res`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:`   `    ``s1 ``=` `"(a-(b+c)+d)"` `    ``s2 ``=` `"a-(b-c-(d+e))-f"` `    ``r1 ``=` `simplify(s1)` `    ``for` `i ``in` `r1:` `        ``if` `i !``=` `None``:` `            ``print``(i, end ``=` `" "``)` `        ``else``:` `            ``break` `    ``print``()` `    ``r2 ``=` `simplify(s2)` `    ``for` `i ``in` `r2:` `        ``if` `i !``=` `None``:` `            ``print``(i, end ``=` `" "``)` `        ``else``:` `            ``break`   `# This code is contributed by PranchalK`

## C#

 `// C# program to simplify algebraic string` `using` `System;` `using` `System.Collections.Generic;`   `class` `GfG ` `{ `   `// Function to simplify the string ` `static` `String simplify(String str) ` `{ ` `    ``int` `len = str.Length; `   `    ``// resultant string of max length equal ` `    ``// to length of input string ` `    ``char` `[]res = ``new` `char``[len]; ` `    ``int` `index = 0, i = 0; `   `    ``// create empty stack ` `    ``Stack<``int``> s = ``new` `Stack<``int``> (); ` `    ``s.Push(0); `   `    ``while` `(i < len)` `    ``{` `          ``// Don't do any operation` `        ``if``(str[i] == ``'('` `&& i == 0)` `        ``{` `            ``i++;` `              ``continue``;` `        ``}` `      `  `        ``if` `(str[i] == ``'+'``)` `        ``{ `   `            ``// If top is 1, flip the operator ` `            ``if` `(s.Peek() == 1) ` `                ``res[index++] = ``'-'``; `   `            ``// If top is 0, append the same operator ` `            ``if` `(s.Peek() == 0) ` `                ``res[index++] = ``'+'``; `   `        ``} ` `        ``else` `if` `(str[i] == ``'-'``)` `        ``{ ` `            ``if` `(s.Peek() == 1) ` `                ``res[index++] = ``'+'``; ` `            ``else` `if` `(s.Peek() == 0) ` `                ``res[index++] = ``'-'``; ` `        ``}` `        ``else` `if` `(str[i] == ``'('` `&& i > 0) ` `        ``{ ` `            ``if` `(str[i - 1] == ``'-'``) ` `            ``{ `   `                ``// x is opposite to the top of stack ` `                ``int` `x = (s.Peek() == 1) ? 0 : 1; ` `                ``s.Push(x); ` `            ``} `   `            ``// push value equal to top of the stack ` `            ``else` `if` `(str[i - 1] == ``'+'``) ` `                ``s.Push(s.Peek()); ` `        ``} `   `        ``// If closing parentheses pop the stack once ` `        ``else` `if` `(str[i]== ``')'``) ` `            ``s.Pop();` `      `  `        ``// copy the character to the result ` `        ``else` `            ``res[index++] = str[i]; ` `        ``i++; ` `    ``} ` `    ``return` `new` `String(res); ` `} `   `// Driver code` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``String s1 = ``"(a-(b+c)+d)"``; ` `    ``String s2 = ``"a-(b-c-(d+e))-f"``; ` `    ``Console.WriteLine(simplify(s1)); ` `    ``Console.WriteLine(simplify(s2));` `}` `} `   `// This code has been contributed by 29AjayKumar`

## Javascript

 ``

Output

```a-b-c+d
a-b+c+d+e-f```

Time Complexity: O(N), Where N is the length of the given string.
Auxiliary Space: O(N)

This article is contributed by Chhavi . If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

My Personal Notes arrow_drop_up
Related Articles