Learn Rust Coding · Lezione

Contare e raggruppare

Scopra i pattern comuni basati sulle mappe.

Lezione 4 di 413 passaggi

Contare e raggruppare è una lezione Learn Rust Coding gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Learn Rust Coding, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Learn Rust Coding include 4 lezioni in totale.

Conteggio degli elementi

Un'attività molto comune consiste nel contare quante volte compare ciascun valore in una raccolta.

Una HashMap che associa ogni valore al relativo conteggio è lo strumento naturale. La chiave è l'elemento e il valore ne rappresenta il conteggio.

Lo schema del conteggio

Per ogni elemento, recuperate il relativo slot, impostate il valore predefinito a zero e aggiungete uno.

L'API entry rende tutto questo una riga unica e chiara. Lo schema funziona per qualsiasi elemento conteggiabile.

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

Conteggio dei caratteri

Le stringhe sono composte da caratteri, quindi potete contare la frequenza delle lettere allo stesso modo.

Iterate con chars() e conteggiate ogni carattere nella mappa.

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

Conteggio delle parole

Per contare le parole, dividete una frase sugli spazi bianchi con split_whitespace.

Ogni parte diventa una chiave. Questa è la base di un semplice analizzatore della frequenza delle parole.

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

Ricerca del conteggio massimo

Una volta ottenuti i conteggi, individuate l'elemento più frequente scorrendo i dati e tenendo traccia del valore più alto.

Potete confrontare il conteggio di ogni voce con il migliore trovato fino a quel 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);
}

Raggruppamento degli elementi

Il raggruppamento inserisce gli elementi in contenitori che condividono una proprietà.

Utilizzi un HashMap dalla chiave del gruppo a un Vec di elementi. L'API delle entry usa per impostazione predefinita un vettore vuoto al primo utilizzo.

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

Raggruppamento per iniziale

Una chiave di raggruppamento naturale è il primo carattere di una parola.

Lo estragga, quindi inserisca ogni parola nel contenitore corrispondente.

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

Raggruppamento per lunghezza

Può raggruppare gli elementi in base a qualsiasi proprietà calcolata, ad esempio la lunghezza di ogni parola.

In questo caso la chiave è un numero e ogni contenitore raccoglie le parole di quella lunghezza.

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

Conteggio degli elementi unici

Per contare i valori distinti, combini un set con una mappa. Oppure raccolga semplicemente gli elementi in un HashSet e ne legga la lunghezza.

In questo modo ottiene il numero di elementi diversi presenti, ignorando le ripetizioni.

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

Visualizzazione dei risultati

Dopo aver contato o raggruppato gli elementi, scorra la mappa per stampare un report.

Ricordi che l'ordine non è specificato; ordini prima le chiavi se ha bisogno di un output stabile.

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

Somma per gruppo

Invece di raccogliere gli elementi, può aggregarli, ad esempio sommando i valori per chiave.

Imposti lo slot inizialmente a zero e aggiunga il valore di ogni elemento, proprio come nel conteggio, ma usando quantità effettive.

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 rapida

Vuole raggruppare le parole in contenitori in base alla loro iniziale.

Rispondi nella lezione interattiva

Riepilogo

Ha contato elementi, caratteri e parole con il pattern delle entry e ha trovato il valore più frequente.

Ha raggruppato gli elementi in contenitori Vec per lettera e lunghezza e ha contato i valori distinti con un HashSet.

Gratis per iniziare

Impara Rust con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi: 39
Lezioni: 144

Inizia a imparare gratis Visualizza il corso completo

Domande Frequenti

La lezione «Contare e raggruppare» è gratuita?

Sì — il testo completo di «Contare e raggruppare» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Learn Rust Coding, passa a CoddyKit PRO. Il corso Learn Rust Coding include 4 lezioni in totale.

Cosa imparerò in «Contare e raggruppare»?

Scopra i pattern comuni basati sulle mappe. Eserciti Learn Rust Coding con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Learn Rust Coding?

Non è richiesta alcuna esperienza precedente. Learn Rust Coding su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Contare e raggruppare»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Learn Rust Coding?

Sì. Ogni lezione Learn Rust Coding include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Learn Rust Coding