Ejercicios resueltos en rust
Los ejercicios que se resuelven son los que puedes encontrar aquí Esperando que sea de utilidad y guía en este lenguaje tan amado XD
1. Cree un programa que le pida su nombre al usuario y y lo salude por su nombre.
use std::io;
fn main(){
let mut nombre = String::new();
let stdin = io::stdin();
println!("¿cómo te llamas?");
stdin.read_line(&mut nombre).expect("error al leer");
println!("Hola {}", nombre);
}
2. Cree un programa que solicite el radio de un circulo y entregue como salida el perímetro y el área del mismo.
use std::io;
fn main(){
let mut radio = String::new();
let stdin=io::stdin();
println!("Introduce el valor del radio");
stdin.read_line(&mut radio).expect("error al leer");
let perimetro:f32;
let area:f32;
let r:f32=radio.trim().parse().unwrap();
perimetro=2.0*3.1416*r;
area=r*r;
area=area*3.1416;
println!("El perímetro del circulo es: {}",perimetro);
println!("El área del circulo es: {}",area);
}3. Cree un programa que permita calcular el promedio de cuatro calificaciones ingresadas por el usuario.
use std::io;
fn main(){
let mut c1=String::new();
let mut c2=String::new();
let mut c3=String::new();
let mut c4=String::new();
let stdin=io::stdin();
println!("Introduce la primera calificación:");
stdin.read_line(&mut c1).expect("Error al leer");
println!("Introduce la segunda calificación:");
stdin.read_line(&mut c2).expect("Error al leer");
println!("Introduce la tercera calificación:");
stdin.read_line(&mut c3).expect("Error al leer");
println!("Introduce la última calificación:");
stdin.read_line(&mut c4).expect("Error al leer);
let ca1:f32=c1.trim().parse().unwrap();
let ca2:f32=c2.trim().parse().unwrap();
let ca3:f32=c3.trim().parse().unwrap();
let ca4:f32=c4.trim().parse().unwrap();
let mut promedio = ca1+ca2+ca3+ca4;
promedio = promedio / 4;
println!("El promedio es: {}",promedio);
}
4. Cree un programa que convierta de centímetros a pulgadas. Una pulgada es igual a 2.54 centímetros.
use std::io;
fn main(){
let mut cm = String::new();
let stdin=io::stdin();
println!("Introduce los centímetros a convertir en pulgadas");
stdin.read_line(&mut cm).expect("Error al leer");
let cmt:f32=cm.trim().parse().unwrap();
let pul=cmt / 2.56;
println!("Los {} centímetros son: {} pulgadas", cmt, pul);
}
5. Escriba un programa que reciba como entrada las longitudes de los dos catetos aa y bb de un triángulo rectángulo, y que entregue como salida el largo de la hipotenusa cc del triángulo, dado por el teorema de Pitágoras.
use std::io;
fn main(){
let mut ca = String::new();
let mut co = String::new();
let stdin=io::stdin();
println!("Introduce el valor del cateto a");
stdin.read_line(&mut ca).expect("Error al leer");
println!("Introduce el valor del cateto b");
stdin.read_line(&mut co).expect("Error al leer");
let mut hip:f32=ca.trim().parse().unwrap();
let mut cop:f32=co.trim().parse().unwrap();
hip= hip * hip;
cop = cop * cop;
let hipo:f32;
hipo = hip + cop;
let hipot:f32;
hipot = hipo.powf(1.0/2.0);
println!("la hipotenusa es: {}", hipot);
}
6. Cree un programa que pregunte al usuario la hora actual t del reloj y un número entero de horas h, que indique qué hora marcará el reloj dentro de h horas.
use std::io;
fn main(){
let mut t = String::new();
let mut h = String::new();
let stdin=io::stdin();
println!("Introduce el valor entero de la hora actual");
stdin.read_line(&mut t).expect("Error al leer");
println!("Introduce una cantidad de horas");
stdin.read_line(&mut h).expect("Error al leer");
let ti:i32=t.trim().parse().unwrap();
let ho:i32=h.trim().parse().unwrap();
let total:i32= ti + ho;
println!("En {} horas, el reloj marcara las {} horas, h, total);
}
7. Cree un programa que solicite al usuario su edad y el programa le muestre las décadas, lustros, años, meses, semana, días, horas y minutos vividos.
use std::io;
fn main(){
let mut edad=String::new();
let stdin=io::stdin();
println!("Introduce tu edad");
stdin.read_line(&mut edad).expect("Error al leer");
let ed:i32=edad.trim().parse().unwrap();
let decadas:i32= ed/10;
let lustro:i32=ed/10;
let mes:i32=ed*12;
let sem:i32=ed*52;
let dias:i32=ed*365;
let horas:i32=dias*24;
let minutos:i32 = horas*60;
}
8. Cree un programa que solicite al usuario el valor de un lado de un cuadrado, calcule el área y el perímetro de un cuadrado.
use std::io;
fn main(){
let mut lado=String::new();
let stdin=io::stdin();
println!("Esctibe el valor de un lado del cuadrado");
stdin.read_line(&mut lado).expect("Error al leer");
let l:i32=lado.trim().parse().unwrap();
let area:i32 = l*l;
let perimetro:i32=l*4;
println!("El área del cuadrado es: {}. El perímetro del cuadrado es: {}",area, perimetro);
}
9. Cree un programa que solicite al usuario la base de un triángulo y su altura, calcule el área del triángulo.
use std::io;
fn main(){
let mut base=String::new();
let mut altura=String::new();
let stdin=io::stdin();
println!("Introduce el valor de la base del triángulo");
stdin.read_line(&mut base).expect("Error al leer");
println!("Introduce el valor de la altura del triángulo");
stdin.read_line(&mut altura).expect("Error a leer");
let b:i32=base.trim().parse().unwrap();
let a:i32=base.trim().parse().unwrap();
let area:i32=(b*a)/2;
println!("El área del triángulo es: {}",area)
}
10. Cree un programa que permita calcular el promedio de los siguientes número: 19, 17, 21, 09, 12, 07.
fn main(){
let prom:i32=(19+17+21+9+12+7)/6;
println!("El promedio es: {}",prom);
}
11. Cree un programa que permita convertir kilogramos a libras (1 kilogramo = 2.2 libras).
use std::io;
fn main(){
let mut k=String::new();
let stdin=io::stdin();
println!("Introdusca el valor de kilogramos a convertir en libras");
stdin.read_line(&mut k).expect("Error al leer");
let ki:f32=k.trim().parse().unwrap();
let libra:f32= ki*2.2;
println!("{} kilogramos en libra es: {}",k,libra);
}
12. Elabore un programa que permita recibir dos números y mostrar la suma, resta, multiplicación y división de esos dos números.
use std::io;
fn main(){
let mut n1=String::new();
let mut n2=String::new();
let stdin=io::stdin();
println!("Introduce el primer valor entero");
stdin.read_line(&mut n1).expect("Error al leer");
println!("Introduce el segundo valor entero");
stdin.read_line(&mut n2).expect("Error al leer");
let nu1:i32=n1.trim().parse().unwrap();
let nu2:i32=n2.trim().parse().unwrap();
let sum:i32=nu1+nu2;
let res:i32=nu1+nu2;
let div:i32=nu1/nu2;
let mul:i32=nu1*nu2;
println!("La suma es: {}, la resta es: {}, la multiplicación es: {},
la división es: {}",sum,res,mul,div);
}
13. Un obrero trabaja 8 horas diarias por quincena y le pagan 50 pesos la hora y de su salario tiene una compensación del 2% y un descuento del 1.5% del IMSS Y 1.2% del ISPT. Escriba un programa que permita calcular el salario neto del trabajador.
use std::io;
fn main(){
let mut ht = String::new();
let stdin=io::stdin();
println!("¿Cuántas horas trabajo? 80hr = 15a");
stdin.read_line(&mut ht).expect("Error al leer");
let hot:f32=ht.trim().parse().unwrap();
let sal:f32=hot*50.0;
let com:f32=sal*0.02;
let salcom:f32= sal + com;
let ims:f32=salcom*0.015;
let ispt:f32=salcom*0.012;
let salnet:f32=salcom - (ims+ispt);
println!("Pago de horas trabajadas: {}",sal);
println!("pago de compensación: {}",com);
println!("Descuento IMSS: {}",ims);
println!("Descuento ISPT: {}",ispt);
println!("Salario neto: {}",salnet);
}
14. Cree un programa que permita convertir Convertir X pies a M metros. P=0.3048.
use std::io;
fn main(){
let mut pies=String::new();
let stdin=io::stdin();
println!("Introduce el número de pies a convertir a metros");
stdin.read_line(&mut pies).expect("Error al leer");
let pis:f32=pies.trim().parse().unwrap();
let mts:f32 = pis/3.2808;
println!("{} pies son {} metros",pies, mts);
}
15. Cree un programa que permita convertir N pulgadas a M metros. 1 Pulgada = 2.54 cm/100 = 0.0254.
use std::io;
fn main(){
let mut pies=String::new();
let stdin=io::stdin();
println!("Introduce el número de pulgadas a convertir a metros");
stdin.read_line(&mut pies).expect("Error al leer");
let pie:f32=pies.trim().parse().unwrap();
let mts:f32= pie/39.370;
println!("{} pies son {} metros",pie,mts);
}
16. Cree un programa que permita convertir X pies a N pulgadas. 1 pie = a 12 pulgadas.
use std::io;
fn main(){
let mut pies = String::new();
let stdin=io::stdin();
println!("Introduce la cantidad de pies a convertir en pulgadas");
stdin.read_line(&mut pies).expect("Error al leer");
let pie:f32=pies.trim().parse().unwrap();
let pulga:f32= pie*12.000;
println!("Los {} pies son {} pulgadas",pies,pulga);
}
17. Cree un programa que permita convertir G galones a L litros.
use std::io;
fn main(){
let mut gal=String::new();
let stdin=io::stdin();
println!("Introduce la cantidad de galones a convertir en litros");
stdin.read_line(&mut gal).expect("Error al leer");
let galo:f32 = gal.trim().parse().unwrap();
let litro:f32 = galo/0.21997;
println!("Los {} galones son {} litros",gal,litro);
}
18. Cree un programa que permita convertir grados centígrados a grados Fahrenheit. (0 °C × 9/5) + 32 = 32 °F.
use std::io;
fn main(){
let mut cent = String::new();
let stdin=io::stdin();
println!("Introduce la cantidad de gradas centígrados a convertir a fahrenheit");
stdin.read_line(&mut cent).expect("Error al leer");
let centi:f32=cent.trim().parse().unwrap();
let fahren:f32 = (centi*1.8000) + 32.00;
println!("Los {} grados centígrados son: {} grados fahrenheit",cent,fahren);
}
19. Cree un programa que imprima sus iniciales en mayúsculas de imprenta, de manera que apunten hacia la parte inferior de la página (acostadas). Construya cada mayúscula de imprenta con la letra que ésta representa.
fn main(){
println!("AAAAAAAAAAAAA");
println!(" A A");
println!(" A A");
println!(" A A");
println!("AAAAAAAAAAAAA");
println!(" JJJJJ ");
println!(" J ");
println!(" J ");
println!(" J ");
println!(" JJJJJJJJJJJJJJ");
}
En estos 19 ejercicios que se han resuelto, se puede observar que solo se ha hecho uso de las partes más básica del lenguaje rust, aún falta hacer uso de estructuras de control y ciclos. Lo que permitirá que este más completo el nivel básico. El enlace al github donde se puede acceder a los códigos fuentes y ejecutables.