Contar y agrupar
Patrones habituales basados en mapas
Contar y agrupar es una lección gratuita de Learn Rust Coding en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Learn Rust Coding, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Learn Rust Coding incluye 4 lecciones en total.
Contar elementos
Una tarea muy habitual consiste en contar cuántas veces aparece cada valor en una colección.
Un HashMap que asocia cada valor con su recuento es la herramienta natural. La clave es el elemento y el valor es su total.
El patrón de recuento
Para cada elemento, busque su posición, establezca cero como valor predeterminado y sume uno.
La API entry convierte esto en una sola línea clara. Este patrón funciona con cualquier elemento que se pueda contar.
use std::collections::HashMap;
fn main() {
let mut counts = HashMap::new();
for n in [1, 1, 2, 3, 3, 3] {
*counts.entry(n).or_insert(0) += 1;
}
println!("threes: {}", counts[&3]);
}Contar caracteres
Las cadenas están formadas por caracteres, así que puede contar la frecuencia de las letras de la misma forma.
Itere con chars() y contabilice cada carácter en el mapa.
use std::collections::HashMap;
fn main() {
let mut freq = HashMap::new();
for c in "banana".chars() {
*freq.entry(c).or_insert(0) += 1;
}
println!("a: {}, n: {}", freq[&'a'], freq[&'n']);
}Contar palabras
Para contar palabras, divida una frase por los espacios en blanco con split_whitespace.
Cada fragmento se convierte en una clave. Esta es la base de un analizador sencillo de frecuencia de palabras.
use std::collections::HashMap;
fn main() {
let text = "go go stop go";
let mut counts = HashMap::new();
for w in text.split_whitespace() {
*counts.entry(w).or_insert(0) += 1;
}
println!("go: {}", counts["go"]);
}Encontrar el recuento máximo
Una vez obtenidos los recuentos, encuentre el elemento más frecuente iterando y realizando un seguimiento del valor más alto.
Puede comparar el recuento de cada entrada con el mejor resultado obtenido hasta el momento.
use std::collections::HashMap;
fn main() {
let mut counts = HashMap::new();
for c in "aabbbc".chars() {
*counts.entry(c).or_insert(0) += 1;
}
let top = counts.iter().max_by_key(|(_, &v)| v).unwrap();
println!("most common: {}", top.0);
}Agrupar elementos
Agrupar consiste en colocar en el mismo grupo los elementos que comparten una propiedad.
Use un HashMap que asocie la clave del grupo con un Vec de elementos. La API entry establece un vector vacío la primera vez que se usa.
use std::collections::HashMap;
fn main() {
let mut groups: HashMap<bool, Vec<i32>> = HashMap::new();
for n in 1..=6 {
groups.entry(n % 2 == 0).or_default().push(n);
}
println!("evens: {:?}", groups[&true]);
}Agrupar por la primera letra
Una clave de agrupación natural es el primer carácter de una palabra.
Extráigalo y, después, añada cada palabra al grupo correspondiente.
use std::collections::HashMap;
fn main() {
let words = ["apple", "avocado", "banana"];
let mut by_letter: HashMap<char, Vec<&str>> = HashMap::new();
for w in words {
let first = w.chars().next().unwrap();
by_letter.entry(first).or_default().push(w);
}
println!("a-words: {}", by_letter[&'a'].len());
}Agrupar por longitud
Puede agrupar por cualquier propiedad calculada, como la longitud de cada palabra.
En este caso, la clave es un número y cada grupo reúne las palabras que tienen esa longitud.
use std::collections::HashMap;
fn main() {
let words = ["hi", "yo", "hey", "hello"];
let mut by_len: HashMap<usize, Vec<&str>> = HashMap::new();
for w in words {
by_len.entry(w.len()).or_default().push(w);
}
println!("len 2: {}", by_len[&2].len());
}Contar elementos únicos
Para contar valores distintos, combine un conjunto con un mapa. O simplemente recopile los valores en un HashSet y consulte su longitud.
Esto indica cuántos elementos diferentes aparecen, sin tener en cuenta las repeticiones.
use std::collections::HashSet;
fn main() {
let visits = ["sam", "mia", "sam", "leo", "mia"];
let unique: HashSet<&str> = visits.iter().copied().collect();
println!("unique visitors: {}", unique.len());
}Presentar resultados
Después de contar o agrupar, recorra el mapa para imprimir un informe.
Recuerde que el orden no está definido; ordene primero las claves si necesita una salida estable.
use std::collections::HashMap;
fn main() {
let mut counts = HashMap::new();
for c in "abca".chars() {
*counts.entry(c).or_insert(0) += 1;
}
let mut keys: Vec<_> = counts.keys().collect();
keys.sort();
for k in keys {
println!("{}: {}", k, counts[k]);
}
}Sumar por grupo
En lugar de recopilar elementos, puede agregarlos, por ejemplo, sumando valores por clave.
Establezca cero como valor predeterminado de la posición y sume el valor de cada elemento, igual que al contar, pero con cantidades reales.
use std::collections::HashMap;
fn main() {
let sales = [("a", 10), ("b", 5), ("a", 3)];
let mut totals: HashMap<&str, i32> = HashMap::new();
for (k, amount) in sales {
*totals.entry(k).or_insert(0) += amount;
}
println!("a total: {}", totals["a"]);
}Comprobación rápida
Quiere agrupar palabras en grupos según su primera letra.
Resumen
Contó elementos, caracteres y palabras con el patrón entry, y encontró el valor más frecuente.
Agrupó elementos en grupos Vec por letra y longitud, y contó los valores distintos con un HashSet.
Preguntas frecuentes
¿La lección «Contar y agrupar» es gratis?
Sí — el texto completo de «Contar y agrupar» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Learn Rust Coding, actualiza a CoddyKit PRO. El curso de Learn Rust Coding incluye 4 lecciones en total.
¿Qué aprenderé en «Contar y agrupar»?
Patrones habituales basados en mapas Practicas Learn Rust Coding con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Learn Rust Coding?
No se requiere experiencia previa. Learn Rust Coding en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.
¿Cuánto tiempo toma la lección «Contar y agrupar»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Learn Rust Coding?
Sí. Cada lección de Learn Rust Coding incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.