wc command

Author: Van-nam Do

.gitignore

@@ -1,2 +1,3 @@
 /target
-.idea
+.idea
+.DS_Store

challenges/wc-command/src/lib.rs

@@ -1,56 +1,70 @@
-use core::num;
-use std::sync::atomic::AtomicUsize;
-use rand::Rng;
-use rayon::{prelude::*, vec};
-use rust_coding_challenges::utils::read_text_file_from_args;
+use core::str;
 use std::cmp::min;
-use std::{fs::*, os};
-use std::io::{BufRead, BufReader, Read};
-use std::sync::{mpsc, Arc, Mutex};
-use std::thread;
-use std::time::Instant;
+use std::fs::File;
+use std::sync::atomic::AtomicUsize;
 use std::sync::atomic::Ordering;
+use std::sync::Arc;
+use std::thread;
+use memmap2::MmapOptions;
 
-pub fn solve(text: &str) -> usize {
-    let num_threads = std::thread::available_parallelism().unwrap().get();
-    count_words_parallel(text, num_threads)
+pub fn read_file_as_string(file_path: &str) -> String {
+    let file = File::open(file_path).expect("Path is not valid");
+    let mmap = unsafe { MmapOptions::new().map(&file).expect("Cannot map from file") };
+    let text = unsafe { str::from_utf8_unchecked(&mmap).to_string() };
+    text
 }
 
+pub fn count_words(text: &str) -> usize {
+    count_in_paralell(text, count_words_in_chunk)
+}
 
+pub fn count_word_occurrences(text: &str, word: String) -> usize {
+    count_in_paralell(text, move |chunk| count_word_occurrences_in_chunk(chunk, &word))
+}
 
-fn count_words_parallel(text: &str, num_threads: usize) -> usize {
+fn count_in_paralell<F>(text: &str, count_fn: F) -> usize
+where
+    F: Fn(&[String]) -> usize + Send + Sync + 'static,
+{
+    let num_threads: usize = std::thread::available_parallelism().unwrap().get();
     let lines: Vec<String> = text.lines().map(|line| line.to_string()).collect();
     let lines_per_thread = (lines.len() + num_threads - 1) / num_threads;
     let total_word_count = Arc::new(AtomicUsize::new(0));
     let mut handles = Vec::new();
+    let count_fn = Arc::new(count_fn);
 
     for i in 0..num_threads {
         let start = lines_per_thread * i;
         let end = min(start + lines_per_thread, lines.len());
-
-        let total_word_count_clone = Arc::clone(&total_word_count);
         let chunk = lines[start..end].to_vec();
+        let count_fn_clone = Arc::clone(&count_fn);
+        let total_word_count_clone = total_word_count.clone();
 
         let handle = thread::spawn(move || {
-            let count = count_words_in_chunk(&chunk);
-            total_word_count_clone.fetch_add(count, Ordering::Relaxed)
+            let count = count_fn_clone(&chunk);
+            total_word_count_clone.fetch_add(count, Ordering::Relaxed);
         });
         handles.push(handle);
     }
+
     for handle in handles {
         handle.join().unwrap();
     }
     total_word_count.load(Ordering::Relaxed)
 }
 
+
 fn count_words_in_chunk(chunk: &[String]) -> usize {
     chunk
         .iter()
         .flat_map(|line| line.split_whitespace())
         .count()
 }
 
-
-// fn count_words_in_chunk(chunk: &str) -> usize {
-//     chunk.split_whitespace().count()
-// }
+fn count_word_occurrences_in_chunk(chunk: &[String], word: &str) -> usize {
+    chunk
+        .iter()
+        .flat_map(|line| line.split_whitespace())
+        .filter(|&w| w == word)
+        .count()
+}

challenges/wc-command/src/main.rs

@@ -1,54 +1,41 @@
 
-use memmap2::MmapOptions;
-use wc_command::solve;
-use std::{fs::File, io::{self, BufRead, BufReader, Read, Write}, str, time::Instant};
+use wc_command::{count_word_occurrences, count_words, read_file_as_string};
+use std::env;
 
-fn main() -> std::io::Result<()> {
-    let start = Instant::now();
-    // let file_path = "/Users/namdo/Desktop/learntocodetogether/random_1m_lines.txt";
-    let file_path = "/Users/namdo/Desktop/learntocodetogether/random_10m_lines.txt";
-    let text = read_file_to_string(file_path)?;
-    let wc = solve(&text);
-    println!("total words: {:?}", wc);
-    println!("total time: {:?}", start.elapsed());
-    println!("OK: {}", 8503930 == wc);
+fn main() {
+    let args: Vec<String> = env::args().collect();
 
-    let time = Instant::now();
-    let file = File::open(file_path)?;
-
-    let mmap = unsafe { MmapOptions::new().map(&file)? };
-    let text = unsafe { str::from_utf8_unchecked(&mmap) };
-    let str_time = Instant::now();
-    println!("finish converting to string: {:?}", str_time.elapsed());
-    solve(text);
-    println!("Elapsed time for mmap: {:?}", time.elapsed());
-    Ok(())
-}
-
-
-fn million_lines(n: usize, file_path: &str, new_file_path: &str) -> io::Result<()> {
-    let mut src = File::open(file_path)?;
-
-    let mut content = String::new();
-    src.read_to_string(&mut content)?;
-
-    let mut des = File::create(new_file_path)?;
-
-    for i in 0..n {
-        des.write_all(content.as_bytes())?;
+    if args.len() < 2 || args[1] != "rccwc" {
+        eprintln!("Usage: rccwc -w <file_path> or rccwc -wo <word> <file_path>");
+        return;
     }
 
-    Ok(())
-}
-
-fn read_file_to_string(file_path: &str) -> io::Result<String>{
-    let file = File::open(file_path)?;
-    let mut reader = BufReader::new(file);
-    let mut buffer = String::new();
-    let mut content = String::new();
-    while reader.read_line(&mut buffer)? > 0 {
-        content.push_str(&buffer);
-        buffer.clear();
+    match args[2].as_str() {
+        "-w" => {
+            if args.len() != 4 {
+                eprintln!("Usage: rccwc -w <file>");
+                return;
+            }
+            let file_path = &args[3];
+            let text = read_file_as_string(&file_path);
+            let total_words = count_words(&text);
+            println!("Total words: {}", total_words);
+        } 
+        "-wo" => {
+            if args.len() != 5 {
+                eprintln!("Usage: rccwc -wc <word> <file_path>");
+                return;
+            }
+            let word = &args[3];
+            let file_path = &args[4];
+            let text = read_file_as_string(&file_path);
+            let total_occurrences = count_word_occurrences(&text, word.to_string());
+            println!("Total occurrences of '{}': {} ", word, total_occurrences);
+        }
+        _ => {
+            eprintln!("Invalid option. Usage: rccwc -w <file_path> or -wo <word> <file_path>")
+        }
     }
-    Ok(content)
+    
 }
+

challenges/wc-command/tests/test.rs

@@ -1,13 +1,9 @@
 #[cfg(test)]
 mod tests {
-    use wc_command::solve;
 
 
     #[test]
     fn test_solve() {
         // Call the solve function and check for expected results
-        let result = solve(str);
-        assert!(result.is_ok());
-        // Add more assertions based on expected behavior
     }
 }