0Pricing
Learn Rust Coding · Aula

Contagem e agrupamento

Padrões comuns baseados em mapas.

Contagem e agrupamento é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Learn Rust Coding, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Learn Rust Coding inclui 4 aulas no total.

Contando elementos

Uma tarefa muito comum é contar quantas vezes cada valor aparece em uma coleção.

Uma HashMap que associa cada valor à sua contagem é a ferramenta natural. A chave é o item e o valor é sua contabilização.

O padrão de contagem

Para cada item, consulte seu espaço, use zero como valor padrão e adicione um.

A API entry transforma isso em uma linha única e clara. Esse padrão funciona para qualquer item que possa ser contado.

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

Contando caracteres

Strings são compostas por caracteres, então você pode contar a frequência das letras da mesma maneira.

Percorra os caracteres com chars() e contabilize cada um no 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']);
}

Contando palavras

Para contar palavras, divida uma frase nos espaços em branco com split_whitespace.

Cada trecho se torna uma chave. Essa é a base de um analisador simples de frequência de palavras.

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

Encontrando a maior contagem

Depois de obter as contagens, encontre o item mais frequente percorrendo os dados e acompanhando o maior valor.

Você pode comparar a contagem de cada entrada com a melhor contagem encontrada até o 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);
}

Agrupando itens

Agrupar coloca em conjuntos os itens que compartilham uma propriedade.

Use uma HashMap que associe a chave do grupo a um Vec de membros. A API entry usa um vetor vazio como padrão na primeira utilização.

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

Agrupando pela primeira letra

Uma chave natural de agrupamento é o primeiro caractere de uma palavra.

Extraia-o e depois use push para colocar cada palavra no conjunto correspondente.

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

Agrupando por comprimento

Você pode agrupar por qualquer propriedade calculada, como o comprimento de cada palavra.

Aqui, a chave é um número, e cada conjunto reúne palavras com esse comprimento.

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

Contando itens únicos

Para contar valores distintos, combine um conjunto com um mapa. Ou simplesmente colete os valores em uma HashSet e leia seu comprimento.

Isso informa quantos itens diferentes aparecem, ignorando as repetições.

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

Apresentando resultados

Depois de contar ou agrupar, percorra o mapa para imprimir um relatório.

Lembre-se de que a ordem não é especificada; ordene as chaves primeiro se precisar de uma saída estável.

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

Somando por grupo

Em vez de coletar membros, você pode agregá-los, por exemplo, somando valores por chave.

Use zero como valor padrão do espaço e adicione o valor de cada item, assim como na contagem, mas com quantidades reais.

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

Verificação rápida

Você quer agrupar palavras em conjuntos pela primeira letra.

Recapitulação

Você contou itens, caracteres e palavras usando o padrão entry e encontrou o valor mais frequente.

Você agrupou itens em conjuntos Vec por letra e comprimento e contou valores distintos com uma HashSet.

Perguntas Frequentes

A aula “Contagem e agrupamento” é grátis?

Sim — o texto completo de “Contagem e agrupamento” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Learn Rust Coding, atualize para CoddyKit PRO. O curso de Learn Rust Coding inclui 4 aulas no total.

O que vou aprender em “Contagem e agrupamento”?

Padrões comuns baseados em mapas. Você pratica Learn Rust Coding com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Learn Rust Coding?

Nenhuma experiência prévia é necessária. Learn Rust Coding no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Contagem e agrupamento”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Learn Rust Coding?

Sim. Cada aula de Learn Rust Coding inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Construindo um HashMap
  2. API de entrada e valores padrão
  3. Trabalhando com HashSet
  4. Contagem e agrupamento
← Voltar para Learn Rust Coding