Learn Rust Coding · Pelajaran

Menghitung dan Mengelompokkan

Pola umum berbasis pemetaan.

Menghitung dan Mengelompokkan adalah pelajaran Learn Rust Coding gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Learn Rust Coding, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Learn Rust Coding mencakup 4 pelajaran total.

Menghitung Berbagai Hal

Tugas yang sangat common adalah menghitung berapa kali setiap nilai muncul dalam suatu koleksi.

HashMap dari nilai ke jumlah adalah alat yang tepat. Kuncinya adalah item, sedangkan nilainya adalah jumlah kemunculannya.

Pola Penghitungan

Untuk setiap item, cari slotnya, tetapkan nilai default nol, lalu tambahkan satu.

API entry menjadikannya satu baris yang jelas. Pola ini berfungsi untuk item apa pun yang dapat dihitung.

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

Menghitung Karakter

String tersusun dari karakter, jadi Anda dapat menghitung frekuensi huruf dengan cara yang sama.

Lakukan iterasi dengan chars() dan hitung setiap karakter ke dalam 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']);
}

Menghitung Kata

Untuk menghitung kata, pisahkan kalimat berdasarkan spasi menggunakan split_whitespace.

Setiap bagian menjadi kunci. Ini adalah dasar penganalisis frekuensi kata sederhana.

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

Menemukan Jumlah Terbesar

Setelah memiliki jumlah kemunculan, temukan item yang paling sering muncul dengan melakukan iterasi dan melacak nilai tertinggi.

Anda dapat membandingkan jumlah setiap entri dengan jumlah terbaik yang ditemukan sejauh ini.

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

Mengelompokkan Item

Pengelompokan menempatkan item ke dalam wadah berdasarkan properti yang sama.

Gunakan HashMap dari kunci grup ke Vec berisi anggota. API entry menetapkan vektor kosong sebagai nilai default saat pertama kali digunakan.

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

Mengelompokkan Berdasarkan Huruf Pertama

Kunci pengelompokan yang alami adalah karakter pertama dari sebuah kata.

Ambil karakter tersebut, lalu masukkan setiap kata ke wadah yang sesuai.

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

Mengelompokkan Berdasarkan Panjang

Anda dapat mengelompokkan berdasarkan properti terhitung apa pun, seperti panjang setiap kata.

Dalam hal ini, kuncinya berupa angka, dan setiap wadah mengumpulkan kata dengan panjang tersebut.

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

Menghitung Item Unik

Untuk menghitung nilai yang berbeda, gabungkan set dengan map. Atau, cukup kumpulkan semuanya ke dalam HashSet dan baca panjangnya.

Hasil ini memberi tahu Anda berapa banyak item berbeda yang muncul, tanpa memperhitungkan pengulangan.

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

Melaporkan Hasil

Setelah menghitung atau mengelompokkan, lakukan perulangan atas map untuk mencetak laporan.

Ingat bahwa urutannya tidak ditentukan; urutkan kuncinya terlebih dahulu jika memerlukan keluaran yang konsisten.

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

Menjumlahkan Tiap Grup

Alih-alih mengumpulkan anggota, Anda dapat menggabungkannya, misalnya menjumlahkan nilai untuk setiap kunci.

Tetapkan nilai default slot ke nol dan tambahkan nilai setiap item, seperti saat menghitung tetapi menggunakan jumlah sebenarnya.

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

Pemeriksaan Singkat

Anda ingin mengelompokkan kata ke dalam wadah berdasarkan huruf pertamanya.

Rangkuman

Anda telah menghitung item, karakter, dan kata dengan pola entry, serta menemukan nilai yang paling sering muncul.

Anda mengelompokkan item ke dalam wadah Vec berdasarkan huruf dan panjang, lalu menghitung nilai berbeda dengan HashSet.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Menghitung dan Mengelompokkan” gratis?

Ya — teks lengkap “Menghitung dan Mengelompokkan” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Learn Rust Coding, upgrade ke CoddyKit PRO. Kursus Learn Rust Coding mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Menghitung dan Mengelompokkan”?

Pola umum berbasis pemetaan. Kamu berlatih Learn Rust Coding dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Learn Rust Coding?

Tidak diperlukan pengalaman sebelumnya. Learn Rust Coding di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.

Berapa lama pelajaran “Menghitung dan Mengelompokkan” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Learn Rust Coding ini?

Ya. Setiap pelajaran Learn Rust Coding menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Learn Rust Coding