rpn.rs en Rust

Evalúa una expresión en notación polaca inversa con una pila Vec.

use std::env;

fn eval(expr: &str) -> Option<f64> {
    let mut stack: Vec<f64> = Vec::new();
    for token in expr.split_whitespace() {
        match token {
            "+" | "-" | "*" | "/" => {
                let b = stack.pop()?;
                let a = stack.pop()?;
                stack.push(match token {
                    "+" => a + b,
                    "-" => a - b,
                    "*" => a * b,
                    _ => a / b,
                });
            }
            num => stack.push(num.parse().ok()?),
        }
    }
    stack.pop()
}

fn main() {
    let expr: String = env::args().skip(1).collect::<Vec<_>>().join(" ");
    match eval(&expr) {
        Some(result) => println!("{result}"),
        None => eprintln!("invalid expression: {expr:?}"),
    }
}

Cómo funciona

1. Los números entran a la pila; los operadores sacan dos.
2. ? sobre pop y parse aborta ante entrada malformada.
3. El valor final de la pila es el resultado.

Palabras clave y builtins usados aquí

• None
• Option
• Some
• String
• Vec
• f64
• fn
• for
• in
• let
• match
• mut
• str
• use

El intento, en números

Líneas

29

Caracteres a escribir

550

Tokens

227

Ritmo de tres estrellas

105 tpm

Al ritmo de tres estrellas de 105 tokens por minuto, este intento toma unos 130 segundos.

Escribe este fragmento

Paso 1 de 1 en Bis; paso 15 de 15 en Propiedad y préstamos.

← Anterior