first exercise!

- create exercise vec statistics calculator (shout out claude)
- finish hacky solution (it works... but at what cost)
- update current state

exercises/vec-stats/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "vec-stats"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]

exercises/vec-stats/src/main.rs

@@ -0,0 +1,71 @@
+fn main() {
+    let test_vec = vec![1, 2, 2, 2, 2, 3, 4, 5]; // should return (3.0, 3, 3)
+
+    println!("{:?}", calculate_stats(test_vec));
+}
+
+#[derive(Debug)]
+struct Stats {
+    mean: f64,
+    median: i32,
+    mode: i32,
+}
+
+fn calculate_stats(numbers: Vec<i32>) -> Stats {
+    use std::collections::HashMap;
+    let mut tmp: Vec<i32> = numbers;
+    let len = tmp.len();
+    tmp.sort();
+
+    let mut median: i32 = 0;
+
+    // median
+    if len % 2 != 0 {
+        median = tmp[len / 2];
+    } else {
+        median = (tmp[len / 2] + tmp[(len / 2) - 1]) / 2;
+    }
+
+    // mean
+    let mut sum: i32 = 0;
+
+    let tmp2 = tmp.clone();
+    for i in tmp2 {
+        sum += i;
+    }
+
+    let mean = sum as f64 / len as f64;
+
+    //mode
+
+    let mut map = HashMap::new();
+
+    let tmp3 = tmp.clone();
+
+    for num in tmp3 {
+        let count = map.entry(num).or_insert(0);
+        *count += 1;
+    }
+
+    let tmp4 = tmp.clone();
+
+    let mut mode_calc = *map.get(&1).unwrap();
+
+    let mut mode: i32 = 0;
+
+    for (k, v) in map {
+        if v > mode_calc {
+            mode = k;
+        }
+    }
+
+    println!("{:?}", tmp4);
+
+    let return_value = Stats {
+        mean: mean,
+        median: median,
+        mode: mode,
+    };
+
+    return_value
+}

exercises/vec-stats/vec-stats-exercise.md

@@ -0,0 +1,26 @@
+# Exercise: Vec Statistics Calculator
+
+**Concepts practiced:** Vec operations, HashMap for counting, basic math functions
+**Objective:** Build a simple stats calculator that takes a list of numbers and returns basic statistics
+
+## Requirements:
+- Create a function `calculate_stats(numbers: Vec<i32>) -> (f64, i32, i32)` that returns (mean, median, mode)
+- Use Vec sorting for median calculation
+- Use HashMap for mode calculation (most frequent number)
+- Handle edge cases (empty vec should panic with clear message)
+
+## Success criteria:
+- Code compiles and runs
+- Test with `vec![1, 2, 3, 3, 4, 5]` returns approximately `(3.0, 3, 3)`
+
+## Stretch goal:
+Return a struct instead of tuple for better readability
+
+## Getting Started:
+1. `cd exercises`
+2. `cargo new vec-stats`
+3. `cd vec-stats`
+4. Implement the function in `src/main.rs` or `src/lib.rs`
+5. Test with the example input
+
+Expected time: 30-45 minutes