# Basic Calculator

## 1. Clarify the problem:

Before we begin, let's clarify the problem statement. The "Basic Calculator" problem asks us to evaluate a mathematical expression represented as a string. The expression can contain the following elements:

- Non-negative integers.
- The addition operator '+' and subtraction operator '-'.
- Parentheses to indicate the order of operations.

## 2. Analyze the problem:

Let's analyze the problem to identify the input, output, and constraints.

**Input:**

- A string representing a valid mathematical expression.

**Output:**

- The result of evaluating the expression.

**Constraints:**

- The input expression is guaranteed to be valid.
- The expression contains only non-negative integers, '+', '-', '(', and ')'.
- The integer division should truncate toward zero.

## 3. Design an algorithm:

To solve this problem, we can use a stack-based approach. Here's the general outline of our algorithm:

- Initialize an empty stack,
`stack`

, to store the intermediate results and operators. - Initialize a variable,
`result`

, to track the current result. - Initialize a variable,
`sign`

, to track the sign of the current number. The initial sign is positive. - Iterate over each character in the expression:
- If the character is a digit, update the
`result`

by multiplying it by 10 and adding the current digit. - If the character is '+' or '-', update the
`result`

by adding the`sign`

multiplied by the current`result`

to the stack. Reset the`result`

to 0 and update the`sign`

based on the current operator. - If the character is '(', push the current
`result`

and`sign`

to the stack, reset the`result`

and`sign`

to 0 and positive, respectively. - If the character is ')', update the
`result`

by adding the`sign`

multiplied by the current`result`

to the stack. Pop the top element from the stack, which represents the previous`sign`

. Update the`result`

by multiplying it with this previous`sign`

and add it to the value popped from the stack, which represents the previous result.

- If the character is a digit, update the
- After iterating over all characters, update the
`result`

by adding the`sign`

multiplied by the current`result`

to the stack. - Return the value on the top of the stack, which represents the final result.

## 4. Explain your approach:

Our approach involves using a stack to evaluate the expression. We iterate over each character in the expression and perform the necessary operations based on the type of character encountered. By keeping track of the result, sign, and using a stack to handle parentheses, we can evaluate the expression and obtain the final result.

## 5. Write clean and readable code:

Let's implement the algorithm in Python:

python

```
def calculate(s):
stack = []
result = 0
sign = 1
i = 0
while i < len(s):
if s[i].isdigit():
num = 0
while i < len(s) and s[i].isdigit():
num = num * 10 + int(s[i])
i += 1
result += sign * num
continue
if s[i] == '+':
sign = 1
elif s[i] == '-':
sign = -1
elif s[i] == '(':
stack.append(result)
stack.append(sign)
result = 0
sign = 1
elif s[i] == ')':
result = stack.pop() * result + stack.pop()
i += 1
return result
```

## 6. Test your code:

Let's test our code with different test cases to ensure its correctness. We'll consider the following cases:

Case 1:

python

```
s = "1 + 2"
```

The expected output is 3.

Case 2:

python

```
s = "2 - 1 + 3"
```

The expected output is 4.

Case 3:

python

`s = "(1+(4+5+2)-3)+(6+8)"`

The expected output is 23.

## 7. Optimize if necessary:

The current implementation provides an efficient solution to the problem, so no further optimizations are necessary.

## 8. Handle error cases:

The problem statement guarantees that the input expression is valid, so we don't need to handle error cases explicitly.

## 9. Discuss complexity analysis:

The time complexity of our solution is O(n), where n is the length of the input expression. This is because we iterate over each character in the expression exactly once.

The space complexity is O(n) as well, where n is the length of the input expression. This is due to the space used by the stack, which can grow up to the size of the expression in the worst case.

In terms of complexity trade-offs, our approach sacrifices some space to achieve a linear time complexity.