// This is a self-contained Rust program that reads the file "/tmp/file.txt",
// splits its content into words (separated by whitespace), divides the word list
// approximately into 4 equal slices, counts the frequency of words in each slice in its own thread,
// and then prints 4 separate JSON dictionaries (one per line) to stdout.
// Compile with: rustc yourfile.rs
// Run with: /path/to/rust_word_count
//
// Note: This program does not use any external crates (no Cargo.toml required).

use std::fs::File;
use std::io::Read;
use std::collections::HashMap;
use std::thread;

fn main() {
    // Read the entire file into a String.
    let mut file = match File::open("/tmp/file.txt") {
        Ok(f) => f,
        Err(e) => {
            eprintln!("Error opening file: {}", e);
            return;
        }
    };

    let mut contents = String::new();
    if let Err(e) = file.read_to_string(&mut contents) {
        eprintln!("Error reading file: {}", e);
        return;
    }

    // Split the file by whitespace into tokens. We preserve punctuation etc.
    // For example, "This is is is, an example" yields tokens: 
    // ["This", "is", "is", "is,", "an", "example"]
    let tokens: Vec<&str> = contents.split_whitespace().collect();
    let total_tokens = tokens.len();

    // We want to split the token list into 4 chunks.
    let num_threads = 4;
    let mut handles = Vec::new();

    // Compute base chunk size and remainder to distribute if tokens not divisible by 4.
    let chunk_size = total_tokens / num_threads;
    let remainder = total_tokens % num_threads;

    // start index for the first chunk
    let mut start = 0;
    for i in 0..num_threads {
        // Calculate end index: distribute the remainder
        // Each of the first `remainder` chunks gets one extra token.
        let extra = if i < remainder { 1 } else { 0 };
        let end = start + chunk_size + extra;
        
        // Create the slice for this chunk (convert &str tokens to owned String for moving into thread)
        // Note: We clone each token string slice for the hashmap.
        let token_slice = tokens[start..end].iter().map(|s| s.to_string()).collect::<Vec<String>>();
        
        // Spawn a thread to count frequencies in this token slice.
        let handle = thread::spawn(move || {
            let mut counts = HashMap::new();
            for token in token_slice {
                *counts.entry(token).or_insert(0) += 1;
            }
            // Return the HashMap.
            counts
        });

        handles.push(handle);
        start = end;
    }

    // Join the threads and print each thread's JSON output on a separate line.
    for handle in handles {
        // Retrieve the counts hashmap from the thread.
        let counts: HashMap<String, usize> = match handle.join() {
            Ok(map) => map,
            Err(_) => {
                eprintln!("A thread panicked");
                continue;
            }
        };

        // Build a JSON dictionary as a String.
        // Format: {"key": value, "key2": value2, ...}
        // We do not worry about key ordering.
        let mut json_parts = Vec::new();
        for (key, value) in counts {
            // Each key is escaped using basic formatting (we assume the key does not include special characters).
            let part = format!("\"{}\": {}", key, value);
            json_parts.push(part);
        }
        let json_output = format!("{{{}}}", json_parts.join(", "));

        // Print the JSON dictionary line.
        println!("{}", json_output);
    }
}

// This is a self-contained Rust program that reads the file "/tmp/file.txt",
// splits its content into words (separated by whitespace), divides the word list
// approximately into 4 equal slices, counts the frequency of words in each slice in its own thread,
// and then prints 4 separate JSON dictionaries (one per line) to stdout.
// Compile with: rustc yourfile.rs
// Run with: /path/to/rust_word_count
//
// Note: This program does not use any external crates (no Cargo.toml required).

use std::fs::File;
use std::io::Read;
use std::collections::HashMap;
use std::thread;

fn main() {
    // Read the entire file into a String.
    let mut file = match File::open("/tmp/file.txt") {
        Ok(f) => f,
        Err(e) => {
            eprintln!("Error opening file: {}", e);
            return;
        }
    };

    let mut contents = String::new();
    if let Err(e) = file.read_to_string(&mut contents) {
        eprintln!("Error reading file: {}", e);
        return;
    }

    // Split the file by whitespace into tokens. We preserve punctuation etc.
    // For example, "This is is is, an example" yields tokens: 
    // ["This", "is", "is", "is,", "an", "example"]
    let tokens: Vec<&str> = contents.split_whitespace().collect();
    let total_tokens = tokens.len();

    // We want to split the token list into 4 chunks.
    let num_threads = 4;
    let mut handles = Vec::new();

    // Compute base chunk size and remainder to distribute if tokens not divisible by 4.
    let chunk_size = total_tokens / num_threads;
    let remainder = total_tokens % num_threads;

    // start index for the first chunk
    let mut start = 0;
    for i in 0..num_threads {
        // Calculate end index: distribute the remainder
        // Each of the first `remainder` chunks gets one extra token.
        let extra = if i < remainder { 1 } else { 0 };
        let end = start + chunk_size + extra;
        
        // Create the slice for this chunk (convert &str tokens to owned String for moving into thread)
        // Note: We clone each token string slice for the hashmap.
        let token_slice = tokens[start..end].iter().map(|s| s.to_string()).collect::<Vec<String>>();
        
        // Spawn a thread to count frequencies in this token slice.
        let handle = thread::spawn(move || {
            let mut counts = HashMap::new();
            for token in token_slice {
                *counts.entry(token).or_insert(0) += 1;
            }
            // Return the HashMap.
            counts
        });

        handles.push(handle);
        start = end;
    }

    // Join the threads and print each thread's JSON output on a separate line.
    for handle in handles {
        // Retrieve the counts hashmap from the thread.
        let counts: HashMap<String, usize> = match handle.join() {
            Ok(map) => map,
            Err(_) => {
                eprintln!("A thread panicked");
                continue;
            }
        };

        // Build a JSON dictionary as a String.
        // Format: {"key": value, "key2": value2, ...}
        // We do not worry about key ordering.
        let mut json_parts = Vec::new();
        for (key, value) in counts {
            // Each key is escaped using basic formatting (we assume the key does not include special characters).
            let part = format!("\"{}\": {}", key, value);
            json_parts.push(part);
        }
        let json_output = format!("{{{}}}", json_parts.join(", "));

        // Print the JSON dictionary line.
        println!("{}", json_output);
    }
}

#!/usr/bin/env rust
use std::collections::HashMap;
use std::fs;
use std::sync::Arc;
use std::thread;

// Given a text and a requested number of chunks, compute chunk boundaries
// that “snap” to token (whitespace) boundaries so that we don’t cut a word in half.
fn chunk_boundaries(text: &str, num_chunks: usize) -> Vec<(usize, usize)> {
    let len = text.len();
    let mut boundaries = Vec::with_capacity(num_chunks);
    if num_chunks == 0 {
        return boundaries;
    }
    // We work in bytes. (This works fine if the file is standard ASCII.)
    let bytes = text.as_bytes();
    let avg = if num_chunks > 0 { len / num_chunks } else { len };

    let mut current_start = 0;
    for _i in 0..(num_chunks - 1) {
        // Candidate end: ideally current_start plus avg.
        let mut candidate = current_start + avg;
        if candidate >= len {
            candidate = len;
        } else {
            // Move candidate forward until we hit whitespace,
            // thereby ensuring we do not break a word.
            while candidate < len && !bytes[candidate].is_ascii_whitespace() {
                candidate += 1;
            }
        }
        let end = candidate;
        boundaries.push((current_start, end));
        // For the next chunk, skip any whitespace so that we start at a token.
        let mut new_start = candidate;
        while new_start < len && bytes[new_start].is_ascii_whitespace() {
            new_start += 1;
        }
        current_start = new_start;
    }
    // Last chunk goes from current_start to end of text.
    boundaries.push((current_start, len));
    boundaries
}

// Given a HashMap, convert it to a JSON string in the format:
// {"key1": count1, "key2": count2, ... }
fn map_to_json(map: &HashMap<String, usize>) -> String {
    let mut s = String::from("{");
    // We do not care about ordering. (And we write JSON “by hand”.)
    let mut first = true;
    for (key, value) in map {
        if !first {
            s.push_str(", ");
        }
        first = false;
        // We assume key does not contain quotes or control characters.
        s.push_str(&format!("\"{}\": {}", key, value));
    }
    s.push('}');
    s
}

fn main() {
    // Read the entire file into a String.
    let contents = fs::read_to_string("/tmp/file.txt")
        .unwrap_or_else(|err| panic!("Could not read /tmp/file.txt: {}", err));

    // Wrap the file contents in an Arc so that threads can share it.
    let contents = Arc::new(contents);

    // Determine approximate boundaries for 4 chunks.
    let boundaries = chunk_boundaries(&contents, 4);
    if boundaries.len() != 4 {
        panic!("Unexpected boundaries length: expected 4, got {}", boundaries.len());
    }

    // Spawn 4 threads, each processing a slice of the file.
    let mut handles = Vec::new();
    for (start, end) in boundaries {
        let contents_clone = Arc::clone(&contents);
        // For each chunk, create a thread that counts each word.
        let handle = thread::spawn(move || {
            // Get the slice for this chunk. This might be empty.
            let part = &contents_clone[start..end];
            let mut map = HashMap::new();
            // Use split_whitespace() so that punctuation remains attached (e.g. "is," remains).
            for word in part.split_whitespace() {
                // Increase the count for this word.
                *map.entry(word.to_string()).or_insert(0) += 1;
            }
            // Return the JSON string for this chunk.
            map_to_json(&map)
        });
        handles.push(handle);
    }

    // Collect the results and print one JSON dictionary per line.
    for handle in handles {
        match handle.join() {
            Ok(json) => println!("{}", json),
            Err(e) => eprintln!("Error joining thread: {:?}", e),
        }
    }
}

#!/usr/bin/env rust
use std::collections::HashMap;
use std::fs;
use std::sync::Arc;
use std::thread;

// Given a text and a requested number of chunks, compute chunk boundaries
// that “snap” to token (whitespace) boundaries so that we don’t cut a word in half.
fn chunk_boundaries(text: &str, num_chunks: usize) -> Vec<(usize, usize)> {
    let len = text.len();
    let mut boundaries = Vec::with_capacity(num_chunks);
    if num_chunks == 0 {
        return boundaries;
    }
    // We work in bytes. (This works fine if the file is standard ASCII.)
    let bytes = text.as_bytes();
    let avg = if num_chunks > 0 { len / num_chunks } else { len };

    let mut current_start = 0;
    for _i in 0..(num_chunks - 1) {
        // Candidate end: ideally current_start plus avg.
        let mut candidate = current_start + avg;
        if candidate >= len {
            candidate = len;
        } else {
            // Move candidate forward until we hit whitespace,
            // thereby ensuring we do not break a word.
            while candidate < len && !bytes[candidate].is_ascii_whitespace() {
                candidate += 1;
            }
        }
        let end = candidate;
        boundaries.push((current_start, end));
        // For the next chunk, skip any whitespace so that we start at a token.
        let mut new_start = candidate;
        while new_start < len && bytes[new_start].is_ascii_whitespace() {
            new_start += 1;
        }
        current_start = new_start;
    }
    // Last chunk goes from current_start to end of text.
    boundaries.push((current_start, len));
    boundaries
}

// Given a HashMap, convert it to a JSON string in the format:
// {"key1": count1, "key2": count2, ... }
fn map_to_json(map: &HashMap<String, usize>) -> String {
    let mut s = String::from("{");
    // We do not care about ordering. (And we write JSON “by hand”.)
    let mut first = true;
    for (key, value) in map {
        if !first {
            s.push_str(", ");
        }
        first = false;
        // We assume key does not contain quotes or control characters.
        s.push_str(&format!("\"{}\": {}", key, value));
    }
    s.push('}');
    s
}

fn main() {
    // Read the entire file into a String.
    let contents = fs::read_to_string("/tmp/file.txt")
        .unwrap_or_else(|err| panic!("Could not read /tmp/file.txt: {}", err));

    // Wrap the file contents in an Arc so that threads can share it.
    let contents = Arc::new(contents);

    // Determine approximate boundaries for 4 chunks.
    let boundaries = chunk_boundaries(&contents, 4);
    if boundaries.len() != 4 {
        panic!("Unexpected boundaries length: expected 4, got {}", boundaries.len());
    }

    // Spawn 4 threads, each processing a slice of the file.
    let mut handles = Vec::new();
    for (start, end) in boundaries {
        let contents_clone = Arc::clone(&contents);
        // For each chunk, create a thread that counts each word.
        let handle = thread::spawn(move || {
            // Get the slice for this chunk. This might be empty.
            let part = &contents_clone[start..end];
            let mut map = HashMap::new();
            // Use split_whitespace() so that punctuation remains attached (e.g. "is," remains).
            for word in part.split_whitespace() {
                // Increase the count for this word.
                *map.entry(word.to_string()).or_insert(0) += 1;
            }
            // Return the JSON string for this chunk.
            map_to_json(&map)
        });
        handles.push(handle);
    }

    // Collect the results and print one JSON dictionary per line.
    for handle in handles {
        match handle.join() {
            Ok(json) => println!("{}", json),
            Err(e) => eprintln!("Error joining thread: {:?}", e),
        }
    }
}