Add word counter exercise with solution and documentation

Author: InboraStudio

src/SUMMARY.md

@@ -118,6 +118,8 @@
   - [`HashMap`](std-types/hashmap.md)
   - [Exercise: Counter](std-types/exercise.md)
     - [Solution](std-types/solution.md)
+  - [Exercise: Word Counter](std-types/word_counter.md)
+    - [Solution](std-types/word_counter_solution.md)
 - [Standard Library Traits](std-traits.md)
   - [Comparisons](std-traits/comparisons.md)
   - [Operators](std-traits/operators.md)

src/std-types/Cargo.toml

@@ -4,6 +4,13 @@ version = "0.1.0"
 edition = "2021"
 publish = false
 
+[dependencies]
+clap = { version = "4.4", features = ["derive"] }
+
 [[bin]]
 name = "hashset"
 path = "exercise.rs"
+
+[[bin]]
+name = "word_counter"
+path = "word_counter.rs"

src/std-types/word_counter.rs

@@ -0,0 +1,140 @@
+// ANCHOR: word_counter
+use std::collections::HashMap;
+use clap::Parser;
+
+/// A word counting program
+#[derive(Parser)]
+#[command(author, version, about, long_about = None)]
+struct Args {
+    /// Text to count words in
+    #[arg(short, long)]
+    text: Option<String>,
+
+    /// File to read text from
+    #[arg(short, long)]
+    file: Option<String>,
+
+    /// Ignore case when counting words
+    #[arg(short, long, default_value_t = true)]
+    ignore_case: bool,
+}
+
+/// WordCounter counts the frequency of words in text.
+struct WordCounter {
+    word_counts: HashMap<String, usize>,
+    ignore_case: bool,
+}
+
+impl WordCounter {
+    /// Create a new WordCounter.
+    fn new(ignore_case: bool) -> Self {
+        WordCounter {
+            word_counts: HashMap::new(),
+            ignore_case,
+        }
+    }
+
+    /// Count words in the given text.
+    fn count_words(&mut self, text: &str) {
+        for word in text.split_whitespace() {
+            let word = if self.ignore_case {
+                word.to_lowercase()
+            } else {
+                word.to_string()
+            };
+            *self.word_counts.entry(word).or_insert(0) += 1;
+        }
+    }
+
+    /// Get the count for a specific word.
+    fn word_count(&self, word: &str) -> usize {
+        let word = if self.ignore_case {
+            word.to_lowercase()
+        } else {
+            word.to_string()
+        };
+        self.word_counts.get(&word).copied().unwrap_or(0)
+    }
+
+    /// Find the most frequent word(s) and their count.
+    fn most_frequent(&self) -> Vec<(&str, usize)> {
+        if self.word_counts.is_empty() {
+            return Vec::new();
+        }
+
+        let max_count = self.word_counts.values().max().unwrap();
+        self.word_counts
+            .iter()
+            .filter(|(_, &count)| count == *max_count)
+            .map(|(word, &count)| (word.as_str(), count))
+            .collect()
+    }
+
+    /// Print word counts in alphabetical order
+    fn print_counts(&self) {
+        let mut words: Vec<_> = self.word_counts.keys().collect();
+        words.sort();
+        for word in words {
+            println!("{}: {}", word, self.word_counts[word]);
+        }
+    }
+}
+// ANCHOR_END: word_counter
+
+// ANCHOR: tests
+#[test]
+fn test_empty_counter() {
+    let counter = WordCounter::new(true);
+    assert_eq!(counter.word_count("any"), 0);
+    assert!(counter.most_frequent().is_empty());
+}
+
+#[test]
+fn test_simple_text() {
+    let mut counter = WordCounter::new(true);
+    counter.count_words("Hello world, hello Rust!");
+    assert_eq!(counter.word_count("hello"), 2);
+    assert_eq!(counter.word_count("rust"), 1);
+    assert_eq!(counter.word_count("world"), 1);
+}
+
+#[test]
+fn test_case_insensitive() {
+    let mut counter = WordCounter::new(true);
+    counter.count_words("Hello HELLO hello");
+    assert_eq!(counter.word_count("hello"), 3);
+    assert_eq!(counter.word_count("HELLO"), 3);
+}
+
+#[test]
+fn test_most_frequent() {
+    let mut counter = WordCounter::new(true);
+    counter.count_words("hello world hello rust hello");
+    let most_frequent = counter.most_frequent();
+    assert_eq!(most_frequent, vec![("hello", 3)]);
+}
+// ANCHOR_END: tests
+
+fn main() {
+    let args = Args::parse();
+    
+    let mut counter = WordCounter::new(args.ignore_case);
+
+    if let Some(text) = args.text {
+        counter.count_words(&text);
+    } else if let Some(file) = args.file {
+        match std::fs::read_to_string(file) {
+            Ok(content) => counter.count_words(&content),
+            Err(e) => {
+                eprintln!("Error reading file: {}", e);
+                std::process::exit(1);
+            }
+        }
+    } else {
+        eprintln!("Please provide either --text or --file");
+        std::process::exit(1);
+    }
+
+    println!("Word counts:");
+    counter.print_counts();
+} 

src/std-types/word_counter_solution.md

@@ -0,0 +1,110 @@
+use std::collections::HashMap;
+use std::error::Error;
+
+fn count_words(text: &str) -> Result<HashMap<String, u32>, Box<dyn Error>> {
+    if text.trim().is_empty() {
+        return Err("Empty input".into());
+    }
+
+    let mut word_counts = HashMap::new();
+    
+    for word in text.split_whitespace() {
+        *word_counts.entry(word.to_lowercase()).or_insert(0) += 1;
+    }
+    
+    Ok(word_counts)
+}
+
+fn print_word_counts(counts: &HashMap<String, u32>) {
+    let mut words: Vec<_> = counts.keys().collect();
+    words.sort();
+    
+    for word in words {
+        println!("{}: {}", word, counts[word]);
+    }
+}
+
+fn main() -> Result<(), Box<dyn Error>> {
+    let text = "The quick brown fox jumps over the lazy dog";
+    let counts = count_words(text)?;
+    print_word_counts(&counts);
+    
+    // Test empty input
+    match count_words("") {
+        Ok(_) => println!("Unexpected success with empty input"),
+        Err(e) => println!("Expected error: {}", e),
+    }
+    
+    Ok(())
+}
+
+struct WordCounter {
+    word_counts: HashMap<String, usize>,
+}
+
+impl WordCounter {
+    fn new() -> Self {
+        WordCounter {
+            word_counts: HashMap::new(),
+        }
+    }
+
+    fn count_words(&mut self, text: &str) {
+        // Convert to lowercase and split into words
+        for word in text.to_lowercase()
+            .split(|c: char| !c.is_alphabetic())
+            .filter(|s| !s.is_empty())
+        {
+            *self.word_counts.entry(word.to_string()).or_insert(0) += 1;
+        }
+    }
+
+    fn word_count(&self, word: &str) -> usize {
+        self.word_counts.get(&word.to_lowercase()).copied().unwrap_or(0)
+    }
+
+    fn most_frequent(&self) -> Vec<(&str, usize)> {
+        if self.word_counts.is_empty() {
+            return Vec::new();
+        }
+
+        let max_count = self.word_counts.values().max().unwrap();
+        self.word_counts
+            .iter()
+            .filter(|(_, &count)| count == *max_count)
+            .map(|(word, &count)| (word.as_str(), count))
+            .collect()
+    }
+}
+
+#[test]
+fn test_empty_counter() {
+    let counter = WordCounter::new();
+    assert_eq!(counter.word_count("any"), 0);
+    assert!(counter.most_frequent().is_empty());
+}
+
+#[test]
+fn test_simple_text() {
+    let mut counter = WordCounter::new();
+    counter.count_words("Hello world, hello Rust!");
+    assert_eq!(counter.word_count("hello"), 2);
+    assert_eq!(counter.word_count("rust"), 1);
+    assert_eq!(counter.word_count("world"), 1);
+}
+
+#[test]
+fn test_case_insensitive() {
+    let mut counter = WordCounter::new();
+    counter.count_words("Hello HELLO hello");
+    assert_eq!(counter.word_count("hello"), 3);
+    assert_eq!(counter.word_count("HELLO"), 3);
+}
+
+#[test]
+fn test_most_frequent() {
+    let mut counter = WordCounter::new();
+    counter.count_words("hello world hello rust hello");
+    let most_frequent = counter.most_frequent();
+    assert_eq!(most_frequent, vec![("hello", 3)]);
+}