post

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);
}
Imagen 1. Código fuente y ejecución del primer ejercicio resuelto en rust. Fuente: tumbrl.com

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);
}
Imagen 2. Solicitando el radio y calculando perímetro y área. Fuente: tumblr.com

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);
}
Imagen 3. Código fuente y ejecución del promedio de cuatro calificaciones. Fuente: tumblr.com

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);
}
Imagen 4. Código fuente y ejecución de conversión de centímetros a pulgadas. Fuente: tumbrl.com

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);
}

Imagen 5. Código fuente y ejecución para calcular de la hipotenusa. Fuente: tumblr.com

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);
}
Imagen 6. Código fuente y ejecución de calculo de hora futura. Fuente: tumblr.com

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;
}
Imagen 7. Código fuente y ejecución del calculo de décadas, lustros, años, meses, días, horas y minutos. Fuente: tumblr.com

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);
}
Imagen 8. Código fuente y ejecución del calculo del perímetro y área de un cuadrado. Fuente: tumblr.com

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)
}
Imagen 9. Código fuente y ejecución del calculo del área de un triángulo. Fuente: tumblr.com

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);
}
Imagen 10. Código fuente y ejecución del calculo de un promedio con valores predeterminados. Fuente: tumblr.com

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);
}
Imagen 11. Código fuente y ejecución para convertir kilos a libras. Fuente: tumblr.com

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);
}
Imagen 12. Código fuente y ejecución de operaciones básicas. Fuente: tumblr.com

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);
}
Imagen 13. Código fuente y ejecución del salario neto de un trabajador. Fuente: Tumblr.com

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); 
}
Imagen 14. Código fuente y ejecución de la conversión de pies a metros. Fuente: tumblr.com

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);
}
Imagen 15. Código fuente y ejecución de convertir pulgadas a metros. Fuente: tumblr.com

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);
}
Imagen 16. Código fuente y ejecución de convertir pies a pulgadas. Fuente: tumblr.com

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);
}
Imagen 17. Código fuente y ejecución de la conversión de galones a litros. Fuente: tumblr.com

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);
}
Imagen 18. Código fuente y ejecución para convertir grados centígrados a fahrenheit. Fuente: tumblr.com

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");
}
Imagen 19. Código fuente y ejecución de imprimir las iniciales de un nombre. Fuente: tumblr.com

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.

Dejar una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *