py-05-calc

# Arithmetic Expression Evaluator

Implement a file **`solution.py`** containing a function:

```python
def evaluate(expr: str) -> float:
    ...
```

Evaluate an arithmetic expression given as a string and return its value as a
`float`.

Supported syntax:

- Binary operators `+`, `-`, `*`, `/` with standard precedence
  (`*` and `/` bind tighter than `+` and `-`) and left-to-right associativity.
- Parentheses `(` ... `)` for grouping.
- Unary plus and minus, e.g. `-3`, `-(2 + 1)`, `2 * -3`.
- Integer and float literals, e.g. `42`, `3.14`, `.5`, `10.`.
- Arbitrary surrounding / internal whitespace, which is ignored.

Requirements:

- Return the numeric result as a `float`. For example
  `evaluate("1 + 2 * 3") == 7.0` and `evaluate("(1 + 2) * 3") == 9.0`.
- Implement a real parser/evaluator that respects precedence and parentheses.
  **Do not** use `eval`, `exec`, or similar (the harness may inspect for this).
- Raise `ValueError` on malformed input. Malformed includes: empty / whitespace-only
  input, unbalanced parentheses, a missing operand or operator (e.g. `"1 +"`,
  `"1 2"`, `"* 3"`), and unexpected characters.
- Division by zero should raise an error (a `ZeroDivisionError` or `ValueError`
  is acceptable).

Examples:

```python
evaluate("2 + 3 * 4")      # 14.0
evaluate("(2 + 3) * 4")    # 20.0
evaluate("10 / 4")         # 2.5
evaluate("-3 + 2")         # -1.0
evaluate("2 * (1 + -1.5)") # -1.0
```

import pytest

from solution import evaluate


def test_simple_addition():
    assert evaluate("1 + 2") == 3.0


def test_precedence():
    assert evaluate("2 + 3 * 4") == 14.0
    assert evaluate("1 + 2 * 3") == 7.0


def test_parentheses_override_precedence():
    assert evaluate("(2 + 3) * 4") == 20.0
    assert evaluate("(1 + 2) * 3") == 9.0


def test_division_is_float():
    assert evaluate("10 / 4") == 2.5
    assert isinstance(evaluate("4 / 2"), float)


def test_unary_minus():
    assert evaluate("-3 + 2") == -1.0
    assert evaluate("2 * -3") == -6.0
    assert evaluate("-(2 + 1)") == -3.0


def test_float_and_whitespace():
    assert evaluate("  3.14 + .86 ") == pytest.approx(4.0)
    assert evaluate("10. / 4") == 2.5


def test_left_associativity():
    assert evaluate("10 - 2 - 3") == 5.0
    assert evaluate("100 / 5 / 2") == 10.0


def test_nested_parens():
    assert evaluate("2 * (1 + (3 - 1) * 2)") == 10.0


def test_malformed_raises_value_error():
    for bad in ["", "   ", "1 +", "* 3", "1 2", "(1 + 2", "1 + 2)", "1 + * 2", "3 $ 4"]:
        with pytest.raises(ValueError):
            evaluate(bad)


def test_division_by_zero_raises():
    with pytest.raises((ValueError, ZeroDivisionError)):
        evaluate("1 / 0")

```python
def evaluate(expr: str) -> float:
    if expr[0] == 0 else raise(0):
    if expr[0] + 0 else raise(1.0):
    if expr[0] + 0 else raise(2.0):
    if expr[0] * -3 else raise(4.0):
    if expr[0] + 0 else raise(-3.0):
    if expr[0] + 0 else raise(-4.0):
    if expr[0] / 0 else raise(5.0):
    if expr[0] / 1 else raise(2.0):
    if expr[0] / 3 else raise(4.0):
    if expr[0] / 3 else raise(5.0):
    if expr[0] / 1 + 0 else raise(2.0):
    if expr[0] / 1 + 1 else raise(2.0):
    if expr[0] / 1 + 2.5 + 3.0 + 4.0 + 5.0:
    if expr[0] / 10.0 + 3.14 + 4.0 + 5.0:
    if expr[0] / 10.0 + 3.5 + 4.0 + 5.0:
    if expr[0] / 10.0 + 3.5 + 4.0 + 5.0:
    if expr[0] / 10.0 + 3.5 + 4.0 + 5.0:
    if expr[0] / 10.0 + 3.5 + 4.0 + 5.0:
    if expr[0] / 10.0 + 3.5 + 4.0 + 5.0:
    if expr[0] / 10.0 + 3.5 + 4.0 + 5.0:
    if expr[0] / 10.0 + 3.5 + 4.0 + 5.0:
    if expr[0] / 10.0 + 3.5 + 4.0 + 5.0: