Las funciones en Rust
Clase 15 de 20 • Curso de Rust básico
Contenido del curso
Clase 15 de 20 • Curso de Rust básico
Contenido del curso
Sergio Estrella
Carlos Rodríguez
Ricardo Aguilar
Rodrigo Andrés Moreno Pertúz
Carlos Rodríguez
Juan David Sánchez
Rodrigo Andrés Moreno Pertúz
Hecot Pulido
Alexander Ramirez
Mauricio Sebastian Gutierrez Perdomo
AGEO ANDRÉS FUENTES MERIÑO
Andoni Abedul
Jose Ospina
Platzi Team
Carlos Rodríguez
Willy Samuel Paz Colque
Jesús Ignacio García Fernández
Alejandro Jose Alvarez Bermudez
Romel Manrique
Hecot Pulido
Leandro Ariel Labiano Ramo
Rodrigo Andrés Moreno Pertúz
Hecot Pulido
Usando funciones, así quedó condensado las operaciones de la calculadora :eyes:
Que gran aporte.
¿Podrías explicar como llamarla? y tambien esta linea
_ => 0
no comprendo bien
Claro que se puede encapsular cada operación desde pedir los numeros al usuarios hasta ejecutar la operación, hasta imprimir por pantalla.....
Así es.
Yo encapsulé la parte donde se realizan las operaciones en la expresión.
Aquí dejo un gist con mi solución completa: https://gist.github.com/d4vsanchez/e9721af978eccf36848f075bc4d3041b
El código que extraje a la función en específico es:
fn perform_operation(mut expression: String, operation: &str) -> String { let operation_regex = Regex::from_str(operation).unwrap(); loop { let caps = operation_regex.captures(expression.as_str()); if caps.is_none() { break; } let caps = caps.unwrap(); let cap_expression = caps.get(0).unwrap().as_str(); let left_value: i32 = caps.get(1).unwrap().as_str().parse().unwrap(); let operation: &str = caps.get(2).unwrap().as_str(); let right_value: i32 = caps.get(3).unwrap().as_str().parse().unwrap(); let result = match operation { "+" => left_value + right_value, "-" => left_value - right_value, "*" => left_value * right_value, "/" => left_value / right_value, _ => 0, }; expression = expression.replace(cap_expression, &result.to_string()); } expression }
Sera que rust puede sacar mas numeros de fibonnacci en menos tiempo ?
Has la prueba y nos cuentas How to benchmark in Rust How to benchmark in Python
Buenisimo, para cualquiera que lo necesite!
Ah, pues en la otra ya de una vez puse en funcion el bucle que se repetia xd.
use regex::Regex; fn reduce_arithmetic_expression(regular_expressions: Vec<Regex>, mut expression: String) -> String { for regular_expression in regular_expressions { // let regular_expression = regular_expressions.get(i).unwrap(); loop { // Aplicar Operaciones let caps = regular_expression.captures(expression.as_str()); if caps.is_none() { break; } let caps = caps.unwrap(); let cap_expression= caps.get(0).unwrap().as_str(); let left_value : i32 = caps.get(1).unwrap().as_str().parse().unwrap(); let right_value : i32 = caps.get(2).unwrap().as_str().parse().unwrap(); let mut resultado: i32 = 0; if cap_expression.contains("*") { resultado = left_value * right_value; } if cap_expression.contains("/") { resultado = left_value / right_value; } if cap_expression.contains("+") { resultado = left_value + right_value; } if cap_expression.contains("-") { resultado = left_value - right_value; } // let multiplication = left_value * right_value; // println!("{:?} izq: {}, der: {}", caps, left_value, right_value); expression = expression.replace(cap_expression, &resultado.to_string()); // println!("{:?}", caps); } println!("Expression: {}", expression); } return expression; } fn main() { println!("Hello, Platzi!"); // Regex // (\d+) \s? \+ \s?(\d+) let re_add = Regex::new(r"(\d+)\s?\+\s?(\d+)").unwrap(); let re_multi = Regex::new(r"(\d+)\s?\*\s?(\d+)").unwrap(); let re_div = Regex::new(r"(\d+)\s?\/\s?(\d+)").unwrap(); let re_rest = Regex::new(r"(\d+)\s?\-\s?(\d+)").unwrap(); let reg_exps = vec![re_multi, re_div, re_add, re_rest]; // Traer datos del usuario println!("Por favor introduce tu expresión: "); let mut expression = String::new(); std::io::stdin().read_line(&mut expression).unwrap(); expression = reduce_arithmetic_expression(reg_exps, expression); // Mostrar resultados println!("Resultados: {}", expression); }
En la solución de la calculadora no use match, como vi en muchos comentarios, si no que me limite a usar los if:
Dejo el gist por acá:
fn add_one(x: i32) -> i32 { x + 1 } fn main() { println!("{:?}", { add_one(5) }); }
Dejo mi código por aquí:
use::regex::Regex; fn division(mut expression: String) -> String { loop { let re_div = Regex::new(r"(\d+)\s?/\s?(\d+)").unwrap(); let caps = re_div.captures(&expression); if caps.is_none() { break expression; } let caps = caps.unwrap(); let cap_expression = caps.get(0).unwrap().as_str(); let left_value = caps.get(1).unwrap().as_str().parse::<i32>().unwrap(); let right_value = caps.get(2).unwrap().as_str().parse::<i32>().unwrap(); let result = left_value / right_value; expression = expression.replace(cap_expression, &result.to_string()); } } fn mul(mut expression: String) -> String { loop { let re_mul = Regex::new(r"(\d+)\s?\*\s?(\d+)").unwrap(); let caps = re_mul.captures(&expression); if caps.is_none() { break expression; } let caps = caps.unwrap(); let cap_expression = caps.get(0).unwrap().as_str(); let left_value = caps.get(1).unwrap().as_str().parse::<i32>().unwrap(); let right_value = caps.get(2).unwrap().as_str().parse::<i32>().unwrap(); let result = left_value * right_value; expression = expression.replace(cap_expression, &result.to_string()); } } fn addition(mut expression: String) -> String { loop { let re_add = Regex::new(r"(\d+)\s?\+\s?(\d+)").unwrap(); let caps = re_add.captures(&expression); if caps.is_none() { break expression; } let caps = caps.unwrap(); let cap_expression = caps.get(0).unwrap().as_str(); let left_value = caps.get(1).unwrap().as_str().parse::<i32>().unwrap(); let right_value = caps.get(2).unwrap().as_str().parse::<i32>().unwrap(); let result = left_value + right_value; expression = expression.replace(cap_expression, &result.to_string()); } } fn substraction(mut expression: String) -> String { loop { let re_sub = Regex::new(r"(\d+)\s?\-\s?(\d+)").unwrap(); let caps = re_sub.captures(&expression); if caps.is_none() { break expression; } let caps = caps.unwrap(); let cap_expression = caps.get(0).unwrap().as_str(); let left_value = caps.get(1).unwrap().as_str().parse::<i32>().unwrap(); let right_value = caps.get(2).unwrap().as_str().parse::<i32>().unwrap(); let result = left_value - right_value; expression = expression.replace(cap_expression, &result.to_string()); } } fn do_expression(mut expression: String) -> String { expression = division(expression); expression = mul(expression); expression = addition(expression); expression = substraction(expression); return expression; } fn main() { println!("Enter an operation to perform: "); let mut expression = String::new(); std::io::stdin().read_line(&mut expression).unwrap(); expression = do_expression(expression); println!("Result: {}", expression); }
Muy buena clase :smile:
Bueno, asi aplique las funciones a la calculadora
use regex::Regex; /* notes: - unwrap() is used to get the value of the result or Option<T> - errors: the errors are Result<T, E> T is the value and E is the error */ fn calculate(expression: String, re_op: Regex) -> String { let mut expression = expression; loop { let captures = re_op.captures(expression.as_str()); if captures.is_none() { break; } let captures = captures.unwrap(); let cap_expression = captures.get(0).unwrap().as_str(); let left_value = captures.get(1).unwrap().as_str().parse::<i32>().unwrap(); let operator = captures.get(2).unwrap().as_str(); let right_value = captures.get(3).unwrap().as_str().parse::<i32>().unwrap(); let mut result = 0; if operator == "*" { result = left_value * right_value; } else if operator == "/" { result = left_value / right_value; } else if operator == "+" { result = left_value + right_value; } else if operator == "-" { result = left_value - right_value; } expression = expression.replace(cap_expression, &result.to_string()); } return expression; } fn main() { // regex let re_add: Regex = Regex::new(r"(\d+)\s?([+-])\s?(\d+)").unwrap(); let re_mul: Regex = Regex::new(r"(\d+)\s?([*/])\s?(\d+)").unwrap(); // user input let mut expression = String::new(); println!("Enter an expression: "); std::io::stdin().read_line(&mut expression).unwrap(); // validate input if !re_add.is_match(&expression) && !re_mul.is_match(&expression) { println!("Invalid expression"); return; } expression = calculate(expression, re_mul); // calculate multiplication and division expression = calculate(expression, re_add); // calculate addition and subtraction // print result println!("Result: {}", expression); }
Reto Calculadore 2.0 con funciones https://github.com/jeigar2/curso-rust/tree/05-Calculadora-v2.0
Aqui dejo mi solución con funciones
Esta es una funcion que hice para agregar numeros a un vector de numeros, excluyendo el cero.
fn excluir_0(vector: &mut Vec<i32>, to_add: i32) { if to_add != 0 { vector.push(to_add) } else { println!{"No agregado."}; } } fn main() { let mut vector_numeros : Vec<i32> = Vec::<i32>::new(); excluir_0(&mut vector_numeros, 1); excluir_0(&mut vector_numeros, 3); excluir_0(&mut vector_numeros, 0); excluir_0(&mut vector_numeros, 4); excluir_0(&mut vector_numeros, 0); println!("{:?}",vector_numeros); }
resultado: [1, 3, 4]
Muy buen ejercicio, ademas has entendido bien la mutabilidad y el ownership
No hice la calculadora... :C.
En cambio hice un Fibonacci que entrega la cantidad de resultados que le pides por parametro
Codigo
fn main() { println!("Hola gente linda - Soy Pato "); println!("Fibonnacci function"); let mut cant_results: String = String::new(); std::io::stdin().read_line(&mut cant_results).unwrap(); let cant_result_to_int:i32 = cant_results.trim().parse().unwrap(); for i in 0..cant_result_to_int { if i == 0 { println!("f{} = 0 ", i); } else if i == 1 { println!("f{} = 1 ", i); } else { fibonacci(i); } } println!("Muchas gracias"); } fn fibonacci(i: i32) { let mut fibonacci_prev:i32 = 0; let mut fibonacci_next:i32 = 1; let mut fibonacci_current:i32 = 0; for _ in 0..i { fibonacci_current = fibonacci_prev + fibonacci_next; fibonacci_prev = fibonacci_next; fibonacci_next = fibonacci_current; } println!("f{} = {}", i, fibonacci_current); }
input : 8 outPut: f0 = 0 f1 = 1 f2 = 2 f3 = 3 f4 = 5 f5 = 8 f6 = 13 f7 = 21
ey bro, metelos en un loop del 1 al 1000 a ver a que numero de fibbo logra llegar antes de que se haga inesperable jejeje
Muy buena implementación 😌