Capítulo 7: Colecciones
Vec, String y HashMap: contando nucleótidos, k-mers y traduciendo codones
Las variables sueltas alcanzan para ejemplos de pizarra; los datos biológicos reales llegan en cantidades. Este capítulo cubre las tres colecciones de la biblioteca estándar que usarás a diario: Vec para listas ordenadas de valores (secuencias de bases, lotes de lecturas), String para texto que se construye dinámicamente, y HashMap para asociar claves con valores —la estructura detrás de todo conteo de frecuencias, desde nucleótidos hasta k-mers. Al final traduciremos nuestro primer gen a proteína usando una tabla de codones.
7.1 Vec<T>: la lista que crece
Un vector guarda cero o más valores del mismo tipo, uno tras otro en el heap. Se crea con Vec::new() (vacío) o con la macro vec![...] (con contenido inicial), y crece con push:
fn main() {
let mut bases = Vec::new(); // el tipo se infiere del primer push
bases.push('A');
bases.push('T');
bases.push('G');
let fases = vec![95.0, 55.0, 72.0]; // con contenido inicial
println!("{} bases, {} fases de PCR", bases.len(), fases.len());
println!("Última base: {}", bases[bases.len() - 1]);
}
// 3 bases, 3 fases de PCR
// Última base: GEl acceso por índice usa corchetes —y como aprendimos con los arreglos, el índice fuera de rango entra en pánico. La alternativa segura es .get(i), que devuelve Option:
fn main() {
let bases = vec!['A', 'T', 'G'];
println!("índice 1: {}", bases[1]); // directo (o pánico)
println!("índice 9: {:?}", bases.get(9)); // Option: seguro
}
// índice 1: T
// índice 9: NoneRecorrer un Vec prestado —la forma más común— se hace con for sobre &vector, y para modificarlo en el recorrido, sobre &mut vector:
fn main() {
let phreds = vec![37, 12, 29, 41];
let mut aprobados = 0;
for q in &phreds { // presta cada elemento
if q >= &30 { // o simplemente: *q >= 30
aprobados += 1;
}
}
println!("{} de {} lecturas pasan Q30", aprobados, phreds.len());
}
// 3 de 4 lecturas pasan Q30Fíjate en el detalle de los préstamos: q es un &i32 (una referencia al elemento), y comparar q >= &30 es el truco idiomático para no escribir *q. Ambas formas son legítimas; la segunda es más explícita para quien empieza. Otras operaciones útiles: pop() quita y devuelve el último elemento (como Option), remove(i) borra por índice, is_empty() y contains(&valor) preguntan por el contenido.
El tipo de los elementos es libre mientras sea único: Vec<Base> con nuestro enum del capítulo 6, Vec<Secuencia> con structs del capítulo 5, o Vec<String> con identificadores de lecturas.
7.2 String a fondo
Ya conocemos la dualidad &str (préstamo de solo lectura) y String (dueño que crece). Volvamos sobre String con las operaciones de construcción que necesitarás en cada reporte:
fn main() {
let mut encabezado = String::from(">genA");
encabezado.push_str(" mini-gen de ejemplo"); // agrega texto
encabezado.push('\n'); // agrega un carácter
println!("{}", encabezado);
let id = "genB";
let descripcion = "región codificante";
let linea = format!(">{} {}", id, descripcion); // junta sin mover nada
println!("{}", linea);
}
// >genA mini-gen de ejemplo
//
// >genB región codificanteformat! es el caballo de batalla: construye un String nuevo con la misma sintaxis de println!, sin apropiarse de sus ingredientes. En cambio, el operador + consume su operando izquierdo (encabezado + otro mueve encabezado, capítulo 4), así que en código nuevo verás casi siempre format! o push_str.
Para examinar texto, los métodos clave son chars() (itera caracteres), bytes() (itera bytes crudos), to_uppercase()/to_lowercase() (devuelven un String nuevo) y trim() (quita espacios y saltos de línea de los extremos — oro puro al leer archivos, próximo capítulo grande):
fn main() {
let linea_sucia = " atgccc\n";
let limpia = linea_sucia.trim().to_uppercase();
println!("'{}' -> '{}'", linea_sucia, limpia);
println!("¿Está vacía? {}", limpia.is_empty());
}
// ' atgccc
// ' -> 'ATGCCC'
// ¿Está vacía? false7.3 HashMap<K, V>: la tabla de asociación
Un HashMap asocia claves con valores: “por cada base, su conteo”; “por cada k-mer, sus apariciones”; “por cada especie, sus registros”. Se crea con HashMap::new() (agregando use std::collections::HashMap; arriba del archivo) y se llena con insert:
use std::collections::HashMap;
fn main() {
let mut masas = HashMap::new(); // aminoácido -> masa monoisotópica (Da)
masas.insert('G', 57.02);
masas.insert('A', 71.04);
masas.insert('S', 87.03);
match masas.get(&'G') {
Some(masa) => println!("La glicina pesa {} Da", masa),
None => println!("aminoácido desconocido"),
}
println!("¿Tenemos la W (triptófano)? {}", masas.contains_key(&'W'));
}
// La glicina pesa 57.02 Da
// ¿Tenemos la W (triptófano)? false.get(clave) devuelve Option<&V> — la clave puede no estar, y ya sabes exactamente cómo lidiar con eso. Reinsertar una clave existente reemplaza su valor. Para recorrer, un for sobre pares (clave, valor):
for (aa, masa) in &masas {
println!("{} = {} Da", aa, masa);
}con una advertencia importante: el orden de recorrido de un HashMap es arbitrario y cambia entre ejecuciones. Para reportes ordenados alfabética o numéricamente, su primo BTreeMap mantiene las claves ordenadas siempre —misma API, distinta estructura interna.
El patrón entry: contar sin mirar dos veces
Contar frecuencias choca con un problema de gallina y huevo: si la clave aún no existe hay que insertarla con 1, y si existe hay que sumarle 1. El patrón entry lo resuelve en una línea:
use std::collections::HashMap;
fn contar_bases(dna: &str) -> HashMap<char, usize> {
let mut conteo = HashMap::new();
for base in dna.chars() {
let contador = conteo.entry(base).or_insert(0);
*contador += 1;
}
conteo
}
fn main() {
let conteo = contar_bases("ATGGCCTTTTAA");
for (base, n) in &conteo {
println!("{}: {}", base, n);
}
}
// A: 3
// T: 5
// G: 2
// C: 2La línea mágica es conteo.entry(base).or_insert(0): busca la entrada de base y, si no existe, la crea con 0; cualquiera sea el caso, devuelve una referencia mutable al contador (&mut usize), que desreferenciamos con * para incrementarla. Compara esto con las cuatro variables contadoras del ejercicio 3.3: mismo resultado, pero sin límite de categorías ni código duplicado — funciona igual con 4 bases, 20 aminoácidos o 4ⁿ k-mers.
7.4 Contar k-mers
Los k-mers (subsecuencias de longitud k) son la unidad de trabajo de la genómica moderna: ensambladores, búsquedas de especies en metagenómica y detección de sesgos de secuenciación se construyen sobre conteos de k-mers. Nuestra versión recorre ventanas de tamaño k con slices:
use std::collections::HashMap;
fn contar_kmers(dna: &str, k: usize) -> HashMap<String, usize> {
let mut kmers = HashMap::new();
if k == 0 || dna.len() < k {
return kmers; // nada que contar
}
for i in 0..=(dna.len() - k) {
let kmer = &dna[i..i + k];
*kmers.entry(kmer.to_string()).or_insert(0) += 1;
}
kmers
}
fn main() {
let conteo = contar_kmers("ATGGCCTTTTAA", 3);
println!("Hay {} k-mers distintos", conteo.len());
println!("El k-mer TTT aparece {} veces", conteo["TTT"]);
}
// Hay 9 k-mers distintos
// El k-mer TTT aparece 2 vecesDos novedades. La cláusula de guarda del inicio evita rangos imposibles (cuando la secuencia es más corta que k): nota cómo devolver temprano un HashMap vacío simplifica el resto. Y conteo["TTT"] es el acceso índice por clave —pánico si la clave no existe; su versión segura es conteo.get("TTT"), de nuevo un Option.
7.5 Proyecto del capítulo: traducción con tabla de codones
La pieza central de la biología molecular también es un problema de asociación: el código genético mapea cada triplete de ADN a un aminoácido. Con un HashMap y las ventanas de 3 en 3 (step_by), nuestro mini-gen se convierte en proteína:
use std::collections::HashMap;
fn tabla_codones() -> HashMap<&'static str, char> {
// subconjunto ilustrativo; el ejercicio 7.5 te reta a completarla
HashMap::from([
("ATT", 'I'), ("GCT", 'A'), ("GCC", 'A'), ("GCA", 'A'),
("TTC", 'F'), ("TTT", 'F'), ("ATG", 'M'), ("TGG", 'W'),
("GAA", 'E'), ("CAA", 'Q'), ("TAA", '*'), ("TAG", '*'),
("TGA", '*'),
])
}
fn traducir(dna: &str) -> String {
let tabla = tabla_codones();
let mut proteina = String::new();
for i in (0..dna.len()).step_by(3) {
if i + 3 > dna.len() {
break; // el final no completa un codón: se ignora
}
let codon = &dna[i..i + 3];
let aa = tabla.get(codon).copied().unwrap_or('X'); // 'X' = desconocido
proteina.push(aa);
}
proteina
}
fn main() {
let gen = "ATGGCCTTTTAA";
println!("ADN: {}", gen);
println!("Proteína: {}", traducir(gen));
}
// ADN: ATGGCCTTTTAA
// Proteína: MAF*Repasemos lo que hace traducir: recorre índices de 3 en 3 (el marco de lectura), corta el codón con un slice, lo busca en la tabla y agrega el aminoácido a la proteína. .copied() convierte el Option<&char> del get en Option<char>, y unwrap_or('X') traduce los codones que no están en la tabla como ‘X’ — la convención estándar para aminoácido desconocido. Para ATGGCCTTTTAA: ATG→M, GCC→A, TTT→F, TAA→*, la proteína MAF*, metionina–alanina–fenilalanina–paro. El dogma central, en 30 líneas de Rust.
7.6 ¿Qué estructura elegir?
| Estructura | Orden | Acceso | Uso biológico típico |
|---|---|---|---|
Vec<T> |
por posición | índice O(1) | lista de lecturas, de bases, de muestras |
String |
por posición | índice O(1) | secuencias que se construyen dinámicamente |
HashMap<K,V> |
ninguno | clave O(1) | conteos: bases, k-mers, aminoácidos |
BTreeMap<K,V> |
por clave | clave O(log n) | conteos que deben imprimirse ordenados |
Regla rápida: si tu dato tiene “posición natural” (una secuencia es una lista ordenada), usa Vec o String; si tu pregunta es “¿cuántas veces aparece X?” o “¿qué valor corresponde a X?”, usa HashMap, y cambia a BTreeMap cuando el orden de salida importe.
Ejercicios
Ejercicio 7.1 · Conteo ordenado
Usando contar_bases, imprime el conteo de ATGGCCTTTTAA ordenado alfabéticamente por base. Pista: recolecta las claves en un Vec, ordénalo con .sort() y consulta el mapa dentro del for.
Solución
use std::collections::HashMap;
fn contar_bases(dna: &str) -> HashMap<char, usize> {
let mut conteo = HashMap::new();
for base in dna.chars() {
*conteo.entry(base).or_insert(0) += 1;
}
conteo
}
fn main() {
let conteo = contar_bases("ATGGCCTTTTAA");
let mut bases: Vec<char> = conteo.keys().copied().collect();
bases.sort();
for base in bases {
println!("{}: {}", base, conteo[&base]);
}
}
// A: 3
// C: 2
// G: 2
// T: 5.keys() itera las claves, .copied() convierte &char en char, .collect() junta todo en un Vec (el capítulo 10 explica esta orquesta completa) y .sort() ordena en su lugar. La alternativa de una línea es usar BTreeMap desde el inicio: let conteo: BTreeMap<char, usize> = ..., y su recorrido ya sale ordenado.
Ejercicio 7.2 · El k-mer más frecuente
Escribe fn kmer_dominante(dna: &str, k: usize) -> (String, usize) que devuelva el k-mer más frecuente y su conteo. Pista: recorre el mapa y conserva el mejor par con un if. Prueba con k=3 en ATGGCCTTTTAA.
Solución
use std::collections::HashMap;
fn contar_kmers(dna: &str, k: usize) -> HashMap<String, usize> {
let mut kmers = HashMap::new();
if k == 0 || dna.len() < k {
return kmers;
}
for i in 0..=(dna.len() - k) {
let kmer = &dna[i..i + k];
*kmers.entry(kmer.to_string()).or_insert(0) += 1;
}
kmers
}
fn kmer_dominante(dna: &str, k: usize) -> (String, usize) {
let conteo = contar_kmers(dna, k);
let mut mejor = (String::new(), 0);
for (kmer, n) in conteo {
if n > mejor.1 {
mejor = (kmer, n);
}
}
mejor
}
fn main() {
let (kmer, n) = kmer_dominante("ATGGCCTTTTAA", 3);
println!("El k-mer dominante es {} ({} veces)", kmer, n);
}
// El k-mer dominante es TTT (2 veces)La función devuelve una tupla (String, usize), que main desempaca en kmer y n. En secuencias reales, el k-mer dominante suele ser un satélite repetido o un artefacto de PCR; en metagenómica comparativa, los perfiles de k-mers son la firma de cada especie.
Ejercicio 7.3 · Lote de secuencias
Crea tres Secuencia (capítulo 5) en un Vec y escribe un for que imprima el id y el contenido GC de cada una, señalando al final cuál tiene el mayor contenido GC.
Solución
struct Secuencia {
id: String,
bases: String,
}
impl Secuencia {
fn nueva(id: &str, bases: &str) -> Secuencia {
Secuencia { id: String::from(id), bases: String::from(bases) }
}
fn contenido_gc(&self) -> f64 {
let g = self.bases.matches('G').count();
let c = self.bases.matches('C').count();
(g + c) as f64 / self.bases.len() as f64 * 100.0
}
}
fn main() {
let secuencias = vec![
Secuencia::nueva("gc_rica", "GCCGGCCTTAAGGC"),
Secuencia::nueva("at_rica", "ATTAATATTAAT"),
Secuencia::nueva("mixta", "ATGGCCTTTTAA"),
];
let mut mejor_id = String::new();
let mut mejor_gc = -1.0;
for s in &secuencias {
let gc = s.contenido_gc();
println!("{}: {:.1}% GC", s.id, gc);
if gc > mejor_gc {
mejor_gc = gc;
mejor_id = s.id.clone();
}
}
println!("Mayor contenido GC: {} ({:.1}%)", mejor_id, mejor_gc);
}
// gc_rica: 71.4% GC
// at_rica: 0.0% GC
// mixta: 41.7% GC
// Mayor contenido GC: gc_rica (71.4%)El recorrido es prestado (&secuencias), así que el Vec conserva sus secuencias para el reporte final. mejor_id guarda un clon del id ganador porque s (prestado) no puede ceder la propiedad de su campo en medio del bucle. Verifica a mano: GCCGGCCTTAAGGC tiene 10 GC de 14 bases ≈ 71.4%.
Ejercicio 7.4 · Encabezados FASTA limpios
Una línea de encabezado FASTA llega como " >genX | región hipotética " (con espacios sobrantes). Escribe código que la normalice a ">genX región hipotética" usando trim(), y que construya con format! un bloque FASTA completo (encabezado + secuencia) para ATGGCCTTTTAA.
Solución
fn main() {
let crudo = " >genX | región hipotética ";
let limpio = crudo.trim().replace(" | ", " ");
let secuencia = "ATGGCCTTTTAA";
let registro_fasta = format!("{}\n{}", limpio, secuencia);
println!("{}", registro_fasta);
}
// >genX región hipotética
// ATGGCCTTTTAAtrim() limpia los extremos y replace normaliza el separador interno; \n en un String es el salto de línea. El bloque resultante es un FASTA válido listo para escribirse a disco —exactamente lo que haremos en el capítulo 12— y para leerlo con cualquier herramienta del laboratorio.
Ejercicio 7.5 · Completa el código genético
Amplía tabla_codones hasta cubrir los 64 codones estándar (busca “tabla de codones ADN” en tu texto de genética favorito) y traduce ATGTGGGAACAA (pista: M, W, E, Q… y el * final si le agregas un paro). Como verificación de sanidad: ATG siempre debe mapear a M, los seis serina (TCT, TCC, TCA, TCG, AGT, AGC) a S, y los tres paros a *.
Solución
use std::collections::HashMap;
fn tabla_codones() -> HashMap<&'static str, char> {
HashMap::from([
("TTT", 'F'), ("TTC", 'F'), ("TTA", 'L'), ("TTG", 'L'),
("CTT", 'L'), ("CTC", 'L'), ("CTA", 'L'), ("CTG", 'L'),
("ATT", 'I'), ("ATC", 'I'), ("ATA", 'I'), ("ATG", 'M'),
("GTT", 'V'), ("GTC", 'V'), ("GTA", 'V'), ("GTG", 'V'),
("TCT", 'S'), ("TCC", 'S'), ("TCA", 'S'), ("TCG", 'S'),
("CCT", 'P'), ("CCC", 'P'), ("CCA", 'P'), ("CCG", 'P'),
("ACT", 'T'), ("ACC", 'T'), ("ACA", 'T'), ("ACG", 'T'),
("GCT", 'A'), ("GCC", 'A'), ("GCA", 'A'), ("GCG", 'A'),
("TAT", 'Y'), ("TAC", 'Y'), ("TAA", '*'), ("TAG", '*'),
("CAT", 'H'), ("CAC", 'H'), ("CAA", 'Q'), ("CAG", 'Q'),
("AAT", 'N'), ("AAC", 'N'), ("AAA", 'K'), ("AAG", 'K'),
("GAT", 'D'), ("GAC", 'D'), ("GAA", 'E'), ("GAG", 'E'),
("TGT", 'C'), ("TGC", 'C'), ("TGA", '*'), ("TGG", 'W'),
("CGT", 'R'), ("CGC", 'R'), ("CGA", 'R'), ("CGG", 'R'),
("AGT", 'S'), ("AGC", 'S'), ("AGA", 'R'), ("AGG", 'R'),
("GGT", 'G'), ("GGC", 'G'), ("GGA", 'G'), ("GGG", 'G'),
])
}
fn traducir(dna: &str) -> String {
let tabla = tabla_codones();
let mut proteina = String::new();
for i in (0..dna.len()).step_by(3) {
if i + 3 > dna.len() {
break;
}
let aa = tabla.get(&dna[i..i + 3]).copied().unwrap_or('X');
proteina.push(aa);
}
proteina
}
fn main() {
println!("{} -> {}", "ATGTGGGAACAA", traducir("ATGTGGGAACAA"));
println!("{} -> {}", "ATGGCCTTTTAATGA", traducir("ATGGCCTTTTAATGA"));
}
// ATGTGGGAACAA -> MWEQ
// ATGGCCTTTTAATGA -> MAF**La tabla completa son 64 entradas y sigue cabiendo cómodamente en una pantalla; el patrón (mapa + ventana + búsqueda) no cambia. Con esto tienes un traductor de genes funcional, y queda lista la pieza central del analizador del proyecto final. ¿Notaste el MAF**? La secuencia tiene dos codones de paro consecutivos: la traducción estándar se detiene en el primero, pero nuestra versión los imprime todos — un detalle que podrás refinar cuando los ejercicios del capítulo 15 lo pidan.
