Learn Rust Coding · Leçon

Compter et regrouper

Découvrez les schémas courants fondés sur des tables associatives.

Compter et regrouper est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn Rust Coding, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn Rust Coding comprend 4 leçons au total.

Compter des éléments

Une tâche très courante consiste à compter le nombre d’apparitions de chaque valeur dans une collection.

Un HashMap associant chaque valeur à son nombre d’occurrences est l’outil naturel. La clé est l’élément et la valeur est son total.

Le schéma du comptage

Pour chaque élément, recherchez son emplacement, donnez-lui zéro par défaut, puis ajoutez un.

L’API entry permet de faire cela sur une seule ligne claire. Ce schéma fonctionne pour tout élément pouvant être compté.

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

Compter des caractères

Les chaînes sont constituées de caractères ; vous pouvez donc compter la fréquence des lettres de la même manière.

Parcourez-les avec chars() et comptabilisez chaque caractère dans la carte.

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

Compter des mots

Pour compter les mots, divisez une phrase sur les espaces avec split_whitespace.

Chaque fragment devient une clé. C’est la base d’un analyseur simple de fréquence des mots.

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

Trouver le nombre maximal

Une fois les occurrences comptées, trouvez l’élément le plus fréquent en parcourant les données et en conservant la valeur la plus élevée.

Vous pouvez comparer le nombre de chaque entrée avec le meilleur résultat obtenu jusque-là.

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

Regrouper des éléments

Le regroupement place les éléments dans des catégories qui partagent une propriété.

Utilisez un HashMap associant la clé du groupe à un Vec de membres. L’API entry utilise un vecteur vide par défaut lors de la première utilisation.

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

Regrouper selon la première lettre

Une clé de regroupement naturelle est le premier caractère d’un mot.

Extrayez-le, puis ajoutez chaque mot à la catégorie correspondante.

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

Regrouper selon la longueur

Vous pouvez regrouper les éléments selon n’importe quelle propriété calculée, comme la longueur de chaque mot.

Ici, la clé est un nombre et chaque catégorie rassemble les mots de cette longueur.

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

Compter les éléments uniques

Pour compter les valeurs distinctes, combinez un ensemble et une carte. Ou recueillez simplement les valeurs dans un HashSet et lisez sa longueur.

Vous connaîtrez ainsi le nombre d’éléments différents présents, sans tenir compte des répétitions.

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

Présenter les résultats

Après avoir compté ou regroupé les éléments, parcourez la carte pour afficher un rapport.

N’oubliez pas que l’ordre n’est pas défini ; triez d’abord les clés si vous avez besoin d’un résultat stable.

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

Faire la somme par groupe

Au lieu de recueillir les membres, vous pouvez les agréger, par exemple en additionnant les valeurs pour chaque clé.

Initialisez l’emplacement à zéro et ajoutez la valeur de chaque élément, comme pour le comptage, mais avec des montants réels.

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

Vérification rapide

Vous souhaitez regrouper les mots dans des catégories selon leur première lettre.

Récapitulatif

Vous avez compté des éléments, des caractères et des mots avec le schéma entry, puis trouvé la valeur la plus fréquente.

Vous avez regroupé des éléments dans des catégories Vec selon la lettre et la longueur, et compté les valeurs distinctes avec un HashSet.

Questions Fréquemment Posées

La leçon « Compter et regrouper » est-elle gratuite ?

Oui — le texte complet de « Compter et regrouper » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn Rust Coding, passe à CoddyKit PRO. Le cours Learn Rust Coding comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Compter et regrouper » ?

Découvrez les schémas courants fondés sur des tables associatives. Tu pratiques Learn Rust Coding avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Learn Rust Coding ?

Aucune expérience préalable n'est requise. Learn Rust Coding sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Compter et regrouper » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Learn Rust Coding ?

Oui. Chaque leçon Learn Rust Coding inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Learn Rust Coding