feat: add challenges files and test cases

src/challenges/challenge-72.md

@@ -0,0 +1,65 @@
+# Challenge 72
+
+### Expression Evaluator
+
+Write a function eval(expr: &str) -> Result<i64, String> that parses and evaluates a mathematical expression string containing integers, +, -, \*, /, and parentheses.
+
+You should:
+
+- Respect operator precedence and parentheses
+- Handle negative numbers and extra whitespace
+- Return Err for invalid expressions instead of panicking
+
+#### Write your solution below
+
+```rust
+
+// Rust Bytes Challenge Issue #90 Expression Evaluator
+
+pub fn eval(expr: &str) -> Result<i64, String> {
+// TODO: implement logic here
+unimplemented!()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn basic_ops() {
+        assert_eq!(eval("3 + 2 * 2").unwrap(), 7);
+        assert_eq!(eval(" 3 / 2 ").unwrap(), 1);
+        assert_eq!(eval(" 3 + 5 / 2 ").unwrap(), 5);
+    }
+
+    #[test]
+    fn with_parentheses() {
+        assert_eq!(eval("(1+(4+5+2)-3)+(6+8)").unwrap(), 23);
+        assert_eq!(eval("2*(5+5*2)/3+(6/2+8)").unwrap(), 21);
+    }
+
+    #[test]
+    fn negative_numbers() {
+        assert_eq!(eval("-2 + 1").unwrap(), -1);
+        assert_eq!(eval("1 - -1").unwrap(), 2);
+    }
+
+    #[test]
+    fn whitespace_chaos() {
+        assert_eq!(eval("  ( 2 + 3 ) * ( 4 - 1 )  ").unwrap(), 15);
+        assert_eq!(eval(" 10  /  3 ").unwrap(), 3);
+    }
+
+    #[test]
+    fn complex_nested() {
+        assert_eq!(eval("((2+3)*(4+(5-3*2)))/2").unwrap(), 5);
+    }
+
+    #[test]
+    fn invalid_expressions() {
+        assert!(eval("2++3").is_err());
+        assert!(eval("(1+2").is_err());
+        assert!(eval("abc").is_err());
+    }
+}
+```

src/challenges/challenge-73.md

@@ -0,0 +1,80 @@
+# Challenge 73
+
+### Flatten Nested Lists
+
+Write a function flatten that flattens arbitrarily nested lists of integers into a single Vec<i64>. The nested type is defined as:
+
+```rust
+#[derive(Debug, Clone, PartialEq)]
+pub enum Nested {
+    Int(i64),
+    List(Vec<Nested>),
+}
+```
+
+You should handle deeply nested structures, and return an empty vector for empty or fully empty nested lists.
+
+#### Write your solution below
+
+```rust
+// Rust Bytes Challenge Issue #91 Flatten Nested Lists
+#[derive(Debug, Clone, PartialEq)]
+pub enum Nested {
+    Int(i64),
+    List(Vec<Nested>),
+}
+
+pub fn flatten(nested: &[Nested]) -> Vec<i64> {
+    // TODO: implement logic here
+    unimplemented!()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn flat_list() {
+        let input = vec![Nested::Int(1), Nested::Int(2), Nested::Int(3)];
+        assert_eq!(flatten(&input), vec![1, 2, 3]);
+    }
+
+    #[test]
+    fn nested_list() {
+        let input = vec![
+            Nested::List(vec![
+                Nested::Int(1),
+                Nested::List(vec![Nested::Int(2), Nested::Int(3)]),
+            ]),
+            Nested::Int(4),
+        ];
+        assert_eq!(flatten(&input), vec![1, 2, 3, 4]);
+    }
+
+    #[test]
+    fn deeply_nested() {
+        let input = vec![
+            Nested::List(vec![
+                Nested::List(vec![Nested::List(vec![Nested::Int(42)])]),
+            ]),
+        ];
+        assert_eq!(flatten(&input), vec![42]);
+    }
+
+    #[test]
+    fn empty_cases() {
+        assert_eq!(flatten(&[]), vec![]);
+        assert_eq!(flatten(&[Nested::List(vec![])]), vec![]);
+    }
+
+    #[test]
+    fn mixed_empty_and_values() {
+        let input = vec![
+            Nested::List(vec![]),
+            Nested::Int(7),
+            Nested::List(vec![Nested::List(vec![]), Nested::Int(8)]),
+        ];
+        assert_eq!(flatten(&input), vec![7, 8]);
+    }
+}
+```

src/challenges/challenge-74.md

@@ -0,0 +1,60 @@
+# Challenge 74
+
+### Grouped by Frequency
+
+Given a list of integers, return a vector of vectors where each inner vector contains all numbers that appear the same number of times, grouped by frequency.
+
+The groups should be ordered by decreasing frequency, and each group’s numbers should be sorted in ascending.
+
+#### Write your solution below
+
+```rust
+
+// Rust Bytes Challenge Issue #92 Grouped by Frequency
+
+pub fn group_by_frequency(nums: Vec<i32>) -> Vec<Vec<i32>> {
+// TODO: implement logic here
+unimplemented!()
+}
+
+#[cfg(test)]
+mod tests {
+use super::\*;
+
+    #[test]
+    fn mixed_frequencies() {
+        let input = vec![4, 3, 1, 3, 2, 2, 2, 4, 4];
+        let expected = vec![vec![2, 4], vec![3], vec![1]];
+        assert_eq!(group_by_frequency(input), expected);
+    }
+
+    #[test]
+    fn all_unique() {
+        let input = vec![5, 4, 3, 2, 1];
+        let expected = vec![vec![1, 2, 3, 4, 5]];
+        assert_eq!(group_by_frequency(input), expected);
+    }
+
+    #[test]
+    fn all_identical() {
+        let input = vec![7, 7, 7, 7];
+        let expected = vec![vec![7]];
+        assert_eq!(group_by_frequency(input), expected);
+    }
+
+    #[test]
+    fn includes_negatives() {
+        let input = vec![-1, -1, 2, 2, 3];
+        let expected = vec![vec![-1, 2], vec![3]];
+        assert_eq!(group_by_frequency(input), expected);
+    }
+
+    #[test]
+    fn empty_input() {
+        let input: Vec<i32> = vec![];
+        let expected: Vec<Vec<i32>> = vec![];
+        assert_eq!(group_by_frequency(input), expected);
+    }
+
+}
+```

src/challenges/challenge-75.md

@@ -0,0 +1,42 @@
+# Challenge 75
+
+### Log Analyzer
+
+You are given a system log file named Mac_2k.log, [located in the src directory](https://github.com/Rust-Bytes/log_analyzer/tree/main/src).
+The file contains real macOS-style log entries that follow this general pattern:
+
+```rust
+<Month> <Day> <Time> <Hostname> <Process>[PID]: <Message>
+```
+
+Write a Rust program that reads and parses the file Mac_2k.log.
+
+Each line should be parsed into:
+
+timestamp - e.g., Jul 1 09:00:55
+
+hostname - e.g., calvisitor-10-105-160-95
+
+process name - e.g., kernel, com.apple.cts, configd, etc.
+
+process ID (PID) - e.g., [0], [43]
+
+log message - everything after the colon
+
+What you need to produce
+
+Per-process stats: Count how many log entries each process generated (process name only, ignore PID).
+
+Per-hostname stats: Count how many entries came from each hostname.
+
+Global stats:
+
+Most frequent process
+
+Most frequent hostname
+
+Optional: Most common keywords in log messages (lowercased, tokenized, stopwords removed)
+
+Write all results to a summary.json file in the structure sample below:
+
+[![Image: Json code sctrutur of what is expected]](https://substackcdn.com/image/fetch/$s_!A9qj!,w_1456,c_limit,f_webp,q_auto:good,fl_progressive:steep/https%3A%2F%2Fsubstack-post-media.s3.amazonaws.com%2Fpublic%2Fimages%2F7877d707-f801-40d0-bb5b-c7bc8290e41a_1882x898.png)

src/challenges/challenge-76.md

@@ -0,0 +1,82 @@
+# Challenge 76
+
+### Zigzag Merge Iterator
+
+Implement an iterator that merges two input iterators of i32 by alternating yields (first from iter1, then iter2, etc.) until both are exhausted.
+
+If one ends early, continue with the remaining from the other.
+
+#### Write your solution below
+
+```rust
+// Rust Bytes Challenge Issue #94 Zigzag Merge Iterator
+
+pub fn zigzag_merge(
+    iter1: impl Iterator<Item = i32>,
+    iter2: impl Iterator<Item = i32>,
+) -> impl Iterator<Item = i32> {
+    // TODO: implement logic here
+    unimplemented!()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_equal_length() {
+        let i1 = vec![1, 3, 5].into_iter();
+        let i2 = vec![2, 4, 6].into_iter();
+        let result: Vec<i32> = zigzag_merge(i1, i2).collect();
+        assert_eq!(result, vec![1, 2, 3, 4, 5, 6]);
+    }
+
+    #[test]
+    fn test_iter1_shorter() {
+        let i1 = vec![1, 3].into_iter();
+        let i2 = vec![2, 4, 6].into_iter();
+        let result: Vec<i32> = zigzag_merge(i1, i2).collect();
+        assert_eq!(result, vec![1, 2, 3, 4, 6]);
+    }
+
+    #[test]
+    fn test_iter2_shorter() {
+        let i1 = vec![1, 3, 5].into_iter();
+        let i2 = vec![2, 4].into_iter();
+        let result: Vec<i32> = zigzag_merge(i1, i2).collect();
+        assert_eq!(result, vec![1, 2, 3, 4, 5]);
+    }
+
+    #[test]
+    fn test_both_empty() {
+        let i1: Vec<i32> = vec![].into_iter();
+        let i2: Vec<i32> = vec![].into_iter();
+        let result: Vec<i32> = zigzag_merge(i1, i2).collect();
+        assert_eq!(result, vec![]);
+    }
+
+    #[test]
+    fn test_one_empty() {
+        let i1 = vec![1, 2, 3].into_iter();
+        let i2: Vec<i32> = vec![].into_iter();
+        let result: Vec<i32> = zigzag_merge(i1, i2).collect();
+        assert_eq!(result, vec![1]);
+    }
+
+    #[test]
+    fn test_negatives() {
+        let i1 = vec![-1, -3].into_iter();
+        let i2 = vec![-2, -4].into_iter();
+        let result: Vec<i32> = zigzag_merge(i1, i2).collect();
+        assert_eq!(result, vec![-1, -2, -3, -4]);
+    }
+
+    #[test]
+    fn test_duplicates() {
+        let i1 = vec![1, 1].into_iter();
+        let i2 = vec![1, 1].into_iter();
+        let result: Vec<i32> = zigzag_merge(i1, i2).collect();
+        assert_eq!(result, vec![1, 1, 1, 1]);
+    }
+}
+```