100 Days of Code - Rust. Day 8, doing magic with Vectors!

100_doc_rust_day8.rs

// Given a list of integers use vector and return:
// - mean (average value of all elements)
// - median (middle of the vector)
// - mode (the value that occurs most often).

use rand::Rng;
use std::collections::HashMap;

// function to generate x amount of random numbers
fn generate_rand_vector(num: u32) -> Vec<u32> {
    // generate a list of numbers:
    let mut rng = rand::thread_rng();
    let mut numbers = Vec::new();
    for _ in 0..num {
        let number = rng.gen_range(0..=250);
        numbers.push(number);
    }
    numbers
}

// get mean from a vector
fn get_mean(vector: &Vec<u32>) -> u32 {
    let vec_len = vector.len() as u32;
    let sum: u32 = vector.iter().sum();
    sum / vec_len
}

// get median
fn get_median(vector: &mut Vec<u32>) -> u32 {
    let median = match (vector.len() as u32) % 2 {
        // even
        0 => {
            // if even we need to do something more.
            // we need to take the two middle points and
            // find the mean between them and return
            let mid_point = vector.len() / 2;

            // this sorts the vector - maybe I can copy the vector into a new one
            vector.sort();

            // new vector for the two middle values
            let mut even_vec = Vec::new();
            even_vec.push(vector[mid_point]);
            even_vec.push(vector[mid_point+1]);

            // using the above function to get the mean
            let middle_value = get_mean(&even_vec);

            middle_value
        },
        // odd
        _ => {
            let mid_point = vector.len() / 2;
            vector.sort();
            let middle_value = vector[mid_point];
            println!("Odd: {}", middle_value);
            middle_value
        },
    };
    // returns the outcome
    median
}

fn get_mode(vector: &Vec<u32>) -> u32 {
    // need to use hash maps here 
    let mut mode_map = HashMap::new();

    for i in vector {
        let count = mode_map.entry(i).or_insert(0);
        *count +=1;
    }
    // convert hash map into a vector:
    let mut sorted: Vec<_> = mode_map.iter().collect();
    // We take 2 values from the vector, a and b 
    // we compare b.1 - the value from the hash map and compare it
    // to a.1 also a value from the hash map
    sorted.sort_by(|a,b|b.1.cmp(a.1));

    // return - dereferenced
    **sorted[0].0
}
fn main() {
    println!("========================================");
    println!("Fun with Vectors");
    println!("========================================");

    // get random numbers
    let mut numbers: Vec<u32> = generate_rand_vector(100);
    println!("{:?}",numbers);

    // mean
    println!("Mean: {}",get_mean(&numbers));

    // median
    println!("Median: {}",get_median(&mut numbers));

    // mode
    println!("Mode: {}",get_mode(&numbers));
}