From e12f25729c272060ce9875f5382b8b6be08e253c Mon Sep 17 00:00:00 2001 From: Oriol Date: Thu, 21 Mar 2024 13:25:05 +0100 Subject: [PATCH] mouredev#4 - Rust --- .../rust/troleomotor10.rs | 129 ++++++++++++++++++ 1 file changed, 129 insertions(+) create mode 100644 Roadmap/04 - CADENAS DE CARACTERES/rust/troleomotor10.rs diff --git a/Roadmap/04 - CADENAS DE CARACTERES/rust/troleomotor10.rs b/Roadmap/04 - CADENAS DE CARACTERES/rust/troleomotor10.rs new file mode 100644 index 0000000000..41b24eb4e4 --- /dev/null +++ b/Roadmap/04 - CADENAS DE CARACTERES/rust/troleomotor10.rs @@ -0,0 +1,129 @@ +use std::collections::HashSet; + +/* + * EJERCICIO: + * Muestra ejemplos de todas las operaciones que puedes realizar con cadenas de caracteres + * en tu lenguaje. Algunas de esas operaciones podrían ser (busca todas las que puedas): + * - Acceso a caracteres específicos, subcadenas, longitud, concatenación, repetición, recorrido, + * conversión a mayúsculas y minúsculas, reemplazo, división, unión, interpolación, verificación... + * + * DIFICULTAD EXTRA (opcional): + * Crea un programa que analice dos palabras diferentes y realice comprobaciones + * para descubrir si son: + * - Palíndromos + * - Anagramas + * - Isogramas +*/ + +fn checkwords(word1: String, word2: String) { + // Saber si una palabra es palindroma -> Palabras que se leen igual de izquierda a derecha que de derecha a izquierda + let invertedword1: String = word1.chars().rev().collect::(); + let invertedword2: String = word1.chars().rev().collect::(); + println!("La palabra {} es una palindroma? {}", word1, word1 == invertedword1); + println!("La palabra {} es una palindroma? {}", word2, word2 == invertedword2); + + // Saber si una palabra en un anagrama -> Palabras que si cambiamos el orden de las letras, son palabras diferentes (Zara = Raza) + let mut string1: Vec = word1.chars().collect(); + let mut string2: Vec = word2.chars().collect(); + string1.sort(); + string2.sort(); + println!("Son anagramas? {:?}", string1 == string2); + + // Saber si es un isograma -> Palabras que tienen letras repetidas + let mut string1_set: HashSet = HashSet::new(); + for c in word1.chars() { + string1_set.insert(c); + } + let string1_fi: String = string1_set.into_iter().collect(); + + let mut string2_set: HashSet = HashSet::new(); + for c in word2.chars() { + string2_set.insert(c); + } + let string2_fi: String = string2_set.into_iter().collect(); + + println!("La palabra {} es un isograma? {}",word1 ,string1_fi.len() < word1.len()); + println!("La palabra {} es un isograma? {}", word2, string2_fi.len() < word2.len()); +} + +fn main(){ + let string1: String = String::from("hello"); + let string2: String = String::from("rust"); + let string3: String = String::from(" github "); + let string4: String = String::from("Mouredev esta en directo en twitch"); + let palabras: Vec<&str> = vec!["Juan", "se", "fue", "a", "comprar", "el", "pan"]; + + // Formateo + let saludo = format!("{string1}, {string2}"); + println!("{saludo}"); + + // Convertir String a int + let numero: String = String::from("34"); + println!("Pasamos una string un valor numerico: {:?}", numero.parse::().unwrap()); + + // Ver si una cadena esta vacía + println!("La cadena2 esta vacía? {}", string2.is_empty()); + + // Obtener una referencia a los bytes que componen la cadena. + println!("La cadena 2 representada en caracteres ASCII es: {:?}", string2.as_bytes()); + + // Obtener posición + let string2_vector: Vec = string2.chars().collect(); + println!("La posición 2 de la cadena 2 es: {:?}", string2_vector[2]); + + // Concatenación + let mut result: String = String::new(); + result.push_str(&string1); + result.push_str(&string2); + + println!("Si concatenamos la string1 y la string2 sale: {}", result); + + // Repetición + println!("String2 repetida 3 veces: {}", &string2.repeat(3)); + + // Longitud + println!("La longitud de la string 1 es de {} caracteres", string1.len()); + + // Busqueda + let incluye: bool = string2.contains("us"); + println!("La string 2 contiene 'us'? {incluye}"); + + // Reemplazo + println!("En la string 1, si remplazamos las 'l' por 'a' quedaria asi: {}", string1.replace("l", "a")); + + // Recorrido + for character in string2.chars() { + println!("{character}") + } + + // División + let text: Vec<&str> = string4.split("en").collect(); + println!("La string 4 dividida por 'en' es: {:?}", text); + + // Mayúsculas y minúsculas + println!("String 2 toda en mayúsculas: {}", string2.to_uppercase()); + println!("String 2 toda en minúsculas: {}", string2.to_lowercase()); + + // Eliminar espacio principio y final + println!("La string sin espacios es: {}", string3.trim()); + + // Búsqueda al principio y al final + println!("La string 2 comienza por ru? {}", string2.starts_with("ru")); + println!("La string 2 comienza por he? {}", string2.starts_with("he")); + println!("La string 2 acabas por llo? {}", string2.ends_with("llo")); + println!("La string 2 acabas por st? {}", string2.ends_with("st")); + + // Búsqueda de la primera posición + println!("La primera letra 't' esta en la posición: {:?}", string4.find("t")); + + // Búsqueda de la ultima posición + println!("La ultima letra 't' se encuentra en la posición: {:?}", string4.rfind("t")); + + // Búsqueda de ocurrencias + println!("La string 4 tiene: {} caracteres", string4.chars().count()); + + // Unión de vector + println!("El vector unido mediante espacios es: {}", palabras.join(" ")); + + checkwords(String::from("radar"), String::from("zara")); +}