rs-03-rpn

# Evaluate RPN

Implement the library file **`src/lib.rs`** exposing:

```rust
pub fn eval_rpn(tokens: &[&str]) -> Result<f64, String>
```

Evaluate a [Reverse Polish Notation](https://en.wikipedia.org/wiki/Reverse_Polish_notation)
expression given as a slice of tokens. Each token is either:

- a number that parses as `f64`, or
- one of the four binary operators `+`, `-`, `*`, `/`.

Evaluation uses a stack: push numbers; for an operator, pop the top two values
`b` (top) then `a` (next) and push the result of `a OP b`. After consuming all
tokens, exactly one value must remain — that value is the result.

Return `Ok(value)` on success, or `Err(message)` (any non-empty message) on
malformed input:

- **too few operands** — an operator with fewer than two values on the stack.
- **leftover operands** — more than one value remains after all tokens consumed
  (or zero tokens / empty input, which leaves no value).
- **unknown token** — a token that is neither a valid `f64` nor a known operator.
- **division by zero** — a `/` whose right operand `b` is `0.0`.

Note: operator order matters for non-commutative operators. For `["3", "4", "-"]`
the result is `3 - 4 = -1.0`, and for `["8", "2", "/"]` it is `8 / 2 = 4.0`.

Examples:

- `eval_rpn(&["2", "3", "+"])` → `Ok(5.0)`
- `eval_rpn(&["5", "1", "2", "+", "4", "*", "+", "3", "-"])` → `Ok(14.0)` (precedence-via-RPN)
- `eval_rpn(&["3", "4", "-"])` → `Ok(-1.0)`
- `eval_rpn(&["1", "+"])` → `Err(..)` (too few operands)
- `eval_rpn(&["1", "2"])` → `Err(..)` (leftover operands)
- `eval_rpn(&["1", "foo", "+"])` → `Err(..)` (unknown token)
- `eval_rpn(&["1", "0", "/"])` → `Err(..)` (division by zero)

Use only the standard library. Tests live in `tests/` and call it as
`challenge::eval_rpn`.

use challenge::eval_rpn;

#[test]
fn basic_eval() {
    assert_eq!(eval_rpn(&["2", "3", "+"]), Ok(5.0));
    assert_eq!(eval_rpn(&["8", "2", "/"]), Ok(4.0));
    assert_eq!(eval_rpn(&["42"]), Ok(42.0));
}

#[test]
fn operator_order_matters() {
    assert_eq!(eval_rpn(&["3", "4", "-"]), Ok(-1.0));
    assert_eq!(eval_rpn(&["10", "4", "-"]), Ok(6.0));
}

#[test]
fn precedence_via_rpn() {
    // (1 + 2) * 4 + 5 - 3  =  14
    assert_eq!(
        eval_rpn(&["5", "1", "2", "+", "4", "*", "+", "3", "-"]),
        Ok(14.0)
    );
}

#[test]
fn err_too_few_operands() {
    assert!(eval_rpn(&["1", "+"]).is_err());
    assert!(eval_rpn(&["+"]).is_err());
}

#[test]
fn err_leftover_operands() {
    assert!(eval_rpn(&["1", "2"]).is_err());
    assert!(eval_rpn(&["1", "2", "3", "+"]).is_err());
}

#[test]
fn err_empty_input() {
    assert!(eval_rpn(&[]).is_err());
}

#[test]
fn err_unknown_token() {
    assert!(eval_rpn(&["1", "foo", "+"]).is_err());
    assert!(eval_rpn(&["1", "2", "%"]).is_err());
}

#[test]
fn err_division_by_zero() {
    assert!(eval_rpn(&["1", "0", "/"]).is_err());
}

You are an expert programmer. Solve the task exactly as specified. Output your solution as fenced code blocks using the required file name(s) and the exact function/type signatures requested. Prefer correctness; do not include prose outside code unless asked.

```rust
pub fn eval_rpn(tokens: &[&str]) -> Result<f64, String> {
    let mut stack: Vec<f64> = Vec::new();

    for token in tokens {
        match token.as_str() {
            "+" => {
                let b = stack.pop().ok_or_else(|| "too few operands".to_string())?;
                let a = stack.pop().ok_or_else(|| "too few operands".to_string())?;
                stack.push(a + b);
            }
            "-" => {
                let b = stack.pop().ok_or_else(|| "too few operands".to_string())?;
                let a = stack.pop().ok_or_else(|| "too few operands".to_string())?;
                stack.push(a - b);
            }
            "*" => {
                let b = stack.pop().ok_or_else(|| "too few operands".to_string())?;
                let a = stack.pop().ok_or_else(|| "too few operands".to_string())?;
                stack.push(a * b);
            }
            "/" => {
                let b = stack.pop().ok_or_else(|| "too few operands".to_string())?;
                let a = stack.pop().ok_or_else(|| "too few operands".to_string())?;
                if b == 0.0 {
                    return Err("division by zero".to_string());
                }
                stack.push(a / b);
            }
            _ => {
                // Attempt to parse as a number
                let num = token.parse::<f64>().map_err(|_| "unknown token".to_string())?;
                stack.push(num);
            }
        }
    }

    if stack.len() != 1 {
        return Err("leftover operands".to_string());
    }

    Ok(stack.pop().unwrap())
}
```

[
  {
    "total": 1,
    "answer": "```rust\npub fn eval_rpn(tokens: &[&str]) -> Result<f64, String> {\n    let mut stack: Vec<f64> = Vec::new();\n\n    for token in tokens {\n        match token.as_str() {\n            \"+\" => {\n                let b = stack.pop().ok_or_else(|| \"too few operands\".to_string())?;\n                let a = stack.pop().ok_or_else(|| \"too few operands\".to_string())?;\n                stack.push(a + b);\n            }\n            \"-\" => {\n                let b = stack.pop().ok_or_else(|| \"too few operands\".to_string())?;\n                let a = stack.pop().ok_or_else(|| \"too few operands\".to_string())?;\n                stack.push(a - b);\n            }\n            \"*\" => {\n                let b = stack.pop().ok_or_else(|| \"too few operands\".to_string())?;\n                let a = stack.pop().ok_or_else(|| \"too few operands\".to_string())?;\n                stack.push(a * b);\n            }\n            \"/\" => {\n                let b = stack.pop().ok_or_else(|| \"too few operands\".to_string())?;\n                let a = stack.pop().ok_or_else(|| \"too few operands\".to_string())?;\n                if b == 0.0 {\n                    return Err(\"division by zero\".to_string());\n                }\n                stack.push(a / b);\n            }\n            _ => {\n                // Attempt to parse as a number\n                let num = token.parse::<f64>().map_err(|_| \"unknown token\".to_string())?;\n                stack.push(num);\n            }\n        }\n    }\n\n    if stack.len() != 1 {\n        return Err(\"leftover operands\".to_string());\n    }\n\n    Ok(stack.pop().unwrap())\n}\n```",
    "passed": 0,
    "test_error": "error[E0658]: use of unstable library feature `str_as_str`\n --> src/lib.rs:5:21\n  |\n5 |         match token.as_str() {\n  |                     ^^^^^^\n  |\n  = note: see issue #130366 <https://github.com/rust-lang/rust/issues/130366> for more information\n\nFor more information about this error, try `rustc --explain E0658`.\nerror: could not compile `challenge` (lib test) due to 1 previous error\nerror: could not compile `challenge` (lib) due to 1 previous error"
  },
  {
    "total": 1,
    "answer": "```rust\npub fn eval_rpn(tokens: &[&str]) -> Result<f64, String> {\n    let mut stack: Vec<f64> = Vec::new();\n\n    for token in tokens {\n        match token {\n            \"+\" => {\n                let b = stack.pop().ok_or_else(|| \"too few operands\".to_string())?;\n                let a = stack.pop().ok_or_else(|| \"too few operands\".to_string())?;\n                stack.push(a + b);\n            }\n            \"-\" => {\n                let b = stack.pop().ok_or_else(|| \"too few operands\".to_string())?;\n                let a = stack.pop().ok_or_else(|| \"too few operands\".to_string())?;\n                stack.push(a - b);\n            }\n            \"*\" => {\n                let b = stack.pop().ok_or_else(|| \"too few operands\".to_string())?;\n                let a = stack.pop().ok_or_else(|| \"too few operands\".to_string())?;\n                stack.push(a * b);\n            }\n            \"/\" => {\n                let b = stack.pop().ok_or_else(|| \"too few operands\".to_string())?;\n                let a = stack.pop().ok_or_else(|| \"too few operands\".to_string())?;\n                if b == 0.0 {\n                    return Err(\"division by zero\".to_string());\n                }\n                stack.push(a / b);\n            }\n            _ => {\n                // Attempt to parse as a number\n                let num = token.parse::<f64>().map_err(|_| \"unknown token\".to_string())?;\n                stack.push(num);\n            }\n        }\n    }\n\n    if stack.len() != 1 {\n        return Err(\"leftover operands\".to_string());\n    }\n\n    Ok(stack.pop().unwrap())\n}\n```",
    "passed": 0,
    "test_error": "error[E0308]: mismatched types\n --> src/lib.rs:6:13\n  |\n5 |         match token {\n  |               ----- this expression has type `&&str`\n6 |             \"+\" => {\n  |             ^^^ expected `&&str`, found `&str`\n  |\n  = note: expected reference `&&_`\n             found reference `&'static _`\nhelp: consider dereferencing to access the inner value using the `Deref` trait\n  |\n5 |         match *token {\n  |               +\n\nerror[E0308]: mismatched types\n  --> src/lib.rs:11:13\n   |\n 5 |         match token {\n   |               ----- this expression has type `&&str`\n...\n11 |             \"-\" => {\n   |             ^^^ expected `&&str`, found `&str`\n   |\n   = note: expected reference `&&_`\n              found reference `&'static _`\nhelp: consider dereferencing to access the inner value using the `Deref` trait\n   |\n 5 |         match *token {\n   |               +\n\nerror[E0308]: mismatched types\n  --> src/lib.rs:16:13\n   |\n 5 |         match token {\n   |               ----- this expression has type `&&str`\n...\n16 |             \"*\" => {\n   |             ^^^ expected `&&str`, found `&str`\n   |\n   = note: expected reference `&&_`\n              found reference `&'static _`\nhelp: consider dereferencing to access the inner value using the `Deref` trait\n   |\n 5 |         match *token {\n   |               +\n\nerror[E0308]: mismatched types\n  --> src/lib.rs:21:13\n   |\n 5 |         match token {\n   |               ----- this expression has type `&&str`\n...\n21 |             \"/\" => {\n   |             ^^^ expected `&&str`, found `&str`\n   |\n   = note: expected reference `&&_`\n              found reference `&'static _`\nhelp: consider dereferencing to access the inner value using the `Deref` trait\n   |\n 5 |         match *token {\n   |               +\n\nFor more information about this error, try `rustc --explain E0308`.\nerror: could not compile `challenge` (lib) due to 4 previous errors\nerror: could not compile `challenge` (lib test) due to 4 previous errors"
  },
  {
    "total": 8,
    "answer": "```rust\npub fn eval_rpn(tokens: &[&str]) -> Result<f64, String> {\n    let mut stack: Vec<f64> = Vec::new();\n\n    for token in tokens {\n        match *token {\n            \"+\" => {\n                let b = stack.pop().ok_or_else(|| \"too few operands\".to_string())?;\n                let a = stack.pop().ok_or_else(|| \"too few operands\".to_string())?;\n                stack.push(a + b);\n            }\n            \"-\" => {\n                let b = stack.pop().ok_or_else(|| \"too few operands\".to_string())?;\n                let a = stack.pop().ok_or_else(|| \"too few operands\".to_string())?;\n                stack.push(a - b);\n            }\n            \"*\" => {\n                let b = stack.pop().ok_or_else(|| \"too few operands\".to_string())?;\n                let a = stack.pop().ok_or_else(|| \"too few operands\".to_string())?;\n                stack.push(a * b);\n            }\n            \"/\" => {\n                let b = stack.pop().ok_or_else(|| \"too few operands\".to_string())?;\n                let a = stack.pop().ok_or_else(|| \"too few operands\".to_string())?;\n                if b == 0.0 {\n                    return Err(\"division by zero\".to_string());\n                }\n                stack.push(a / b);\n            }\n            _ => {\n                // Attempt to parse as a number\n                let num = token.parse::<f64>().map_err(|_| \"unknown token\".to_string())?;\n                stack.push(num);\n            }\n        }\n    }\n\n    if stack.len() != 1 {\n        return Err(\"leftover operands\".to_string());\n    }\n\n    Ok(stack.pop().unwrap())\n}\n```",
    "passed": 8,
    "test_error": ""
  }
]