Learn Rust Coding · Lekcja

Zliczanie i grupowanie

Pozna Pan/Pani typowe wzorce oparte na mapach.

Zliczanie i grupowanie to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Learn Rust Coding, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Learn Rust Coding zawiera 4 lekcji w sumie.

Zliczanie elementów

Bardzo częstym zadaniem jest policzenie, ile razy każda wartość występuje w kolekcji.

Naturalnym narzędziem jest HashMap mapująca wartości na liczniki. Kluczem jest element, a wartością — liczba jego wystąpień.

Schemat zliczania

Dla każdego elementu znajdź odpowiadające mu miejsce, ustaw wartość domyślną na zero i zwiększ ją o jeden.

API wpisów pozwala zapisać to w jednym, czytelnym wierszu. Ten schemat działa dla dowolnych elementów, które można zliczać.

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

Zliczanie znaków

Łańcuchy znaków składają się ze znaków, więc częstotliwość występowania liter można zliczać w ten sam sposób.

Przejdź po znakach za pomocą chars() i zliczaj każdy z nich w mapie.

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

Zliczanie słów

Aby zliczyć słowa, podziel zdanie w miejscach występowania białych znaków za pomocą split_whitespace.

Każdy fragment staje się kluczem. To podstawa prostego analizatora częstotliwości słów.

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

Znajdowanie największej liczby wystąpień

Gdy masz już zliczone elementy, znajdź najczęściej występujący, przechodząc po elementach i zapamiętując największą wartość.

Możesz porównywać licznik każdego wpisu z najlepszym wynikiem znalezionym do tej pory.

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

Grupowanie elementów

Grupowanie umieszcza elementy w wiaderkach, których elementy mają wspólną właściwość.

Użyj HashMap, która mapuje klucz grupy na Vec zawierający jej elementy. Przy pierwszym użyciu API wpisów ustawia pusty wektor jako wartość domyślną.

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

Grupowanie według pierwszej litery

Naturalnym kluczem grupowania jest pierwszy znak słowa.

Wyodrębnij go, a następnie dodaj każde słowo do odpowiedniego wiaderka.

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

Grupowanie według długości

Możesz grupować elementy według dowolnej obliczonej właściwości, na przykład długości każdego słowa.

W tym przypadku kluczem jest liczba, a każde wiaderko zbiera słowa o danej długości.

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

Zliczanie unikatowych elementów

Aby zliczyć wartości unikatowe, połącz zbiór z mapą. Możesz też po prostu zebrać elementy do HashSet i odczytać jego długość.

Dowiesz się w ten sposób, ile różnych elementów występuje, ignorując powtórzenia.

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

Prezentowanie wyników

Po zliczeniu lub pogrupowaniu elementów przejdź po mapie w pętli, aby wyświetlić raport.

Pamiętaj, że kolejność nie jest określona; jeśli potrzebujesz stabilnego wyniku, najpierw posortuj klucze.

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

Sumowanie w grupach

Zamiast zbierać elementy, możesz je agregować, na przykład sumować wartości dla każdego klucza.

Ustaw wartość domyślną miejsca na zero i dodaj wartość każdego elementu — tak jak przy zliczaniu, ale z rzeczywistymi wartościami.

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

Szybkie sprawdzenie

Chcesz pogrupować słowa w wiaderka według ich pierwszej litery.

Podsumowanie

Zliczasz elementy, znaki i słowa za pomocą schematu wpisu oraz znajdujesz wartość występującą najczęściej.

Grupujesz elementy w wiaderkach Vec według litery i długości, a także zliczasz unikatowe wartości za pomocą HashSet.

Często zadawane pytania

Czy lekcja „Zliczanie i grupowanie” jest bezpłatna?

Tak — pełny tekst „Zliczanie i grupowanie” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Learn Rust Coding, przejdź na CoddyKit PRO. Kurs Learn Rust Coding zawiera 4 lekcji w sumie.

Co nauczysz się w „Zliczanie i grupowanie”?

Pozna Pan/Pani typowe wzorce oparte na mapach. Ćwiczysz Learn Rust Coding z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Learn Rust Coding?

Nie wymagamy żadnego doświadczenia. Learn Rust Coding w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Zliczanie i grupowanie”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Learn Rust Coding?

Tak. Każda lekcja Learn Rust Coding zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Learn Rust Coding