Thought Process:

**Example 1**: `calculate(2+2*3)`

can be sectioned into `2 + calculate(2*3)`

.

The idea is: for `+`

& `-`

operation, we can recursively calling `calculate(subString)`

function. Yes, you get it, it will be a `DFS`

.

for `*`

& `/`

operation, it is in-place operation: we get the result without calling `calculate()`

.

**Example 2**: `2+3*4+4*5`

the result is achieved by the following processes:

`2`

+`calculate(3*4+4*5)`

- And
`calculate(3*4+4*5)`

will be achieved by`12 + calculate(4*5)`

.`12`

is computed from`3*4`

in place. - And
`calculate(4*5)`

will be achieved by`4*5`

in place.

And finally it is the code:

```
public int calculate(String s) {
if(s == "" || s == " ") return 0;
// the following variables will be used for multiply/divide operation
int op1 = 0;
int op2 = 0;
boolean fop = false;
char optype = '0';
// these two used for addition/subtraction operation
int left = 0;
int right = 0;
for(int i = 0; i < s.length(); i++) {
switch(s.charAt(i)) {
case '\0': // should be considered for SPACE character
break;
case '+':
case '-':
if(fop == true){
left = (optype == '*') ? (op1 * op2) : (op1 / op2);
}
else
left = op1;
right = calculate(s.substring(i+1, s.length()));
return (s.charAt(i) == '+') ? left + right : left - right;
case '*':
case '/':
optype = s.charAt(i);
fop = true;
break;
default:
if(fop == false)
op1 = op1 * 10 + s.charAt(i) - '0';
else
op2 = op2 * 10 + s.charAt(i) - '0';
break;
}
}
if(fop==false) // for string only contains digit "234"
return op1;
else // for string only contains multiply/divide operation, like "2*2"
return (optype == '*') ? (op1 * op2) : (op1 / op2);
}
```

I called it the Boilerplate code simply because:

- For
`SPACE`

, need more tweet. - For
`(`

&`)`

, need more tweet. - It is possible to eliminate
`left & right`

variable and use`op1 & op2`

. I simply don't like to sacrifice the readability.

And I will tag this problem as `String`

and `DFS`

.

Time Complexity:

- Come to the idea: 5 mins.
- Key in the code: 10 mins.
- Tweet the code that can run run relatively complex string: 10 mins.
- Refine the code: 10 mins.
- Post my solution: 30 mins.

If you read here, it is a great honor for me. Thank you.