Learn Rust Coding · Lektion

Zählen und gruppieren

Gängige map-basierte Muster.

Lektion 4 von 413 Schritte

Zählen und gruppieren ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Learn Rust Coding-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Learn Rust Coding-Kurs umfasst insgesamt 4 Lektionen.

Elemente zählen

Eine sehr häufige Aufgabe besteht darin zu zählen, wie oft jeder Wert in einer Sammlung vorkommt.

Eine HashMap von Werten zu deren Anzahl ist dafür das naheliegende Werkzeug. Der Schlüssel ist das Element, der Wert dessen Zählerstand.

Das Zählmuster

Suchen Sie für jedes Element seinen Eintrag, setzen Sie ihn standardmäßig auf null und erhöhen Sie ihn um eins.

Die Entry-API macht daraus eine einzige, übersichtliche Zeile. Dieses Muster funktioniert für jedes zählbare Element.

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

Zeichen zählen

Zeichenketten bestehen aus Zeichen. Daher können Sie die Häufigkeit von Buchstaben auf dieselbe Weise zählen.

Durchlaufen Sie die Zeichen mit chars() und zählen Sie jedes einzelne in der Map.

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

Wörter zählen

Um Wörter zu zählen, teilen Sie einen Satz mit split_whitespace an Leerraum auf.

Jedes Teilstück wird zu einem Schlüssel. Das ist die Grundlage für eine einfache Analyse der Worthäufigkeit.

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

Die höchste Anzahl finden

Sobald Sie Zählwerte haben, finden Sie das häufigste Element, indem Sie die Werte durchlaufen und den höchsten Wert verfolgen.

Sie können den Zählerstand jedes Eintrags mit dem bisher besten vergleichen.

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

Elemente gruppieren

Beim Gruppieren werden Elemente in Gruppen eingeordnet, die eine Eigenschaft gemeinsam haben.

Verwenden Sie eine HashMap vom Gruppenschlüssel zu einem Vec mit den Elementen. Die Entry-API verwendet beim ersten Zugriff standardmäßig einen leeren Vektor.

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

Nach Anfangsbuchstaben gruppieren

Ein naheliegender Gruppenschlüssel ist das erste Zeichen eines Wortes.

Ermitteln Sie es und fügen Sie dann jedes Wort in die passende Gruppe ein.

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

Nach Länge gruppieren

Sie können nach jeder berechneten Eigenschaft gruppieren, zum Beispiel nach der Länge jedes Wortes.

Der Schlüssel ist hier eine Zahl, und jede Gruppe sammelt Wörter mit dieser Länge.

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

Eindeutige Elemente zählen

Um unterschiedliche Werte zu zählen, kombinieren Sie eine Menge mit einer Map. Oder sammeln Sie sie einfach in einem HashSet und ermitteln Sie dessen Länge.

So erfahren Sie, wie viele verschiedene Elemente vorkommen, ohne Wiederholungen zu berücksichtigen.

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

Ergebnisse ausgeben

Durchlaufen Sie nach dem Zählen oder Gruppieren die Map, um einen Bericht auszugeben.

Die Reihenfolge ist nicht festgelegt. Sortieren Sie die Schlüssel zuerst, wenn Sie eine stabile Ausgabe benötigen.

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

Pro Gruppe summieren

Statt Elemente zu sammeln, können Sie sie auch aggregieren, etwa indem Sie Werte pro Schlüssel summieren.

Setzen Sie den Eintrag standardmäßig auf null und addieren Sie den Wert jedes Elements – genau wie beim Zählen, aber mit echten Beträgen.

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

Kurztest

Sie möchten Wörter anhand ihres Anfangsbuchstabens in Gruppen einteilen.

Beantworte es in der interaktiven Lektion

Zusammenfassung

Sie haben mithilfe des Entry-Musters Elemente, Zeichen und Wörter gezählt und den häufigsten Wert gefunden.

Sie haben Elemente nach Buchstabe und Länge in Vec-Gruppen eingeordnet und unterschiedliche Werte mit einem HashSet gezählt.

Kostenlos starten

Lerne Rust mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse: 39
Lektionen: 144

Kostenlos lernen Den vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „Zählen und gruppieren“ kostenlos?

Ja — der vollständige Text von „Zählen und gruppieren“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Learn Rust Coding-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Learn Rust Coding-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Zählen und gruppieren“?

Gängige map-basierte Muster. Du übst Learn Rust Coding mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Learn Rust Coding zu starten?

Keine Vorkenntnisse erforderlich. Learn Rust Coding auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Zählen und gruppieren“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Learn Rust Coding-Lektion Code schreiben und ausführen?

Ja. Jede Learn Rust Coding-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Learn Rust Coding