From c363f2685065cc69ddf39474c678de4f712f0043 Mon Sep 17 00:00:00 2001
From: dxphilo <developerphilo@gmail.com>
Date: Thu, 12 Feb 2026 13:31:50 +0300
Subject: [PATCH] feat: add challenges files and test cases

---
 src/challenges/challenge-72.md |  65 +++++++++++
 src/challenges/challenge-73.md |  80 ++++++++++++++
 src/challenges/challenge-74.md |  60 +++++++++++
 src/challenges/challenge-75.md |  42 ++++++++
 src/challenges/challenge-76.md |  82 ++++++++++++++
 src/challenges/challenge-77.md | 190 +++++++++++++++++++++++++++++++++
 6 files changed, 519 insertions(+)
 create mode 100644 src/challenges/challenge-72.md
 create mode 100644 src/challenges/challenge-73.md
 create mode 100644 src/challenges/challenge-74.md
 create mode 100644 src/challenges/challenge-75.md
 create mode 100644 src/challenges/challenge-76.md
 create mode 100644 src/challenges/challenge-77.md

diff --git a/src/challenges/challenge-72.md b/src/challenges/challenge-72.md
new file mode 100644
index 0000000..f6702c9
--- /dev/null
+++ b/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());
+    }
+}
+```
diff --git a/src/challenges/challenge-73.md b/src/challenges/challenge-73.md
new file mode 100644
index 0000000..e65ddc4
--- /dev/null
+++ b/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]);
+    }
+}
+```
diff --git a/src/challenges/challenge-74.md b/src/challenges/challenge-74.md
new file mode 100644
index 0000000..c197857
--- /dev/null
+++ b/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);
+    }
+
+}
+```
diff --git a/src/challenges/challenge-75.md b/src/challenges/challenge-75.md
new file mode 100644
index 0000000..edaa0af
--- /dev/null
+++ b/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)
diff --git a/src/challenges/challenge-76.md b/src/challenges/challenge-76.md
new file mode 100644
index 0000000..6d247cd
--- /dev/null
+++ b/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]);
+    }
+}
+```
diff --git a/src/challenges/challenge-77.md b/src/challenges/challenge-77.md
new file mode 100644
index 0000000..84f7383
--- /dev/null
+++ b/src/challenges/challenge-77.md
@@ -0,0 +1,190 @@
+# Challenge 77
+
+### Graph Gossip
+
+In a small town, rumors spread via a directed graph of gossipers, each person (node) tells secrets to others (edges).
+
+Implement a function to find if there’s a “rumor loop” (cycle) and, if not, return the order in which everyone hears the first rumor (topological sort: sources first).
+
+#### Write your solution below
+
+```rust
+// Rust Bytes Challenge Issue #98 Graph Gossip️
+
+use std::collections::HashMap;
+
+pub fn topological_sort(graph: &HashMap<String, Vec<String>>) -> Result<Vec<String>, Vec<String>> {
+    // TODO: Implement this function
+    todo!()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    // Helper to validate topo order (checks all edges A->B have pos(A) < pos(B))
+    fn is_valid_topo_order(order: &[String], graph: &HashMap<String, Vec<String>>) -> bool {
+        let pos: HashMap<&String, usize> = order.iter().enumerate().map(|(i, n)| (n, i)).collect();
+        for (from, neighbors) in graph {
+            if let Some(&p_from) = pos.get(from) {
+                for to in neighbors {
+                    if let Some(&p_to) = pos.get(to) {
+                        if p_from >= p_to {
+                            return false;
+                        }
+                    } else {
+                        return false;
+                    } // Missing node? Invalid
+                }
+            }
+        }
+        true
+    }
+
+    #[test]
+    fn test_empty_graph() {
+        let graph: HashMap<String, Vec<String>> = HashMap::new();
+        assert_eq!(topological_sort(&graph), Ok(vec![]));
+    }
+
+    #[test]
+    fn test_single_node_no_edges() {
+        let mut graph = HashMap::new();
+        graph.insert("Alice".to_string(), vec![]);
+        let result = topological_sort(&graph).unwrap();
+        assert_eq!(result, vec!["Alice"]);
+    }
+
+    #[test]
+    fn test_single_node_self_loop() {
+        let mut graph = HashMap::new();
+        graph.insert("Bob".to_string(), vec!["Bob".to_string()]);
+        let err = topological_sort(&graph).unwrap_err();
+        assert_eq!(err, vec!["Bob"]);
+    }
+
+    #[test]
+    fn test_simple_dag() {
+        let mut graph = HashMap::new();
+        graph.insert("A".to_string(), vec!["B".to_string(), "C".to_string()]);
+        graph.insert("B".to_string(), vec!["D".to_string()]);
+        graph.insert("C".to_string(), vec!["D".to_string()]);
+        graph.insert("D".to_string(), vec![]);
+
+        let result = topological_sort(&graph).unwrap();
+        assert_eq!(result.len(), 4);
+        assert!(is_valid_topo_order(&result, &graph));
+    }
+
+    #[test]
+    fn test_disconnected_components() {
+        let mut graph = HashMap::new();
+        graph.insert("X".to_string(), vec!["Y".to_string()]);
+        graph.insert("Y".to_string(), vec![]);
+        graph.insert("P".to_string(), vec!["Q".to_string()]);
+        graph.insert("Q".to_string(), vec![]);
+
+        let result = topological_sort(&graph).unwrap();
+        assert_eq!(result.len(), 4);
+        assert!(is_valid_topo_order(&result, &graph));
+    }
+
+    #[test]
+    fn test_simple_cycle() {
+        let mut graph = HashMap::new();
+        graph.insert("E".to_string(), vec!["F".to_string()]);
+        graph.insert("F".to_string(), vec!["G".to_string()]);
+        graph.insert("G".to_string(), vec!["E".to_string()]);
+
+        let err = topological_sort(&graph).unwrap_err();
+        assert_eq!(err.len(), 3);
+        assert!(err.contains(&"E".to_string()));
+        assert!(err.contains(&"F".to_string()));
+        assert!(err.contains(&"G".to_string()));
+    }
+
+    #[test]
+    fn test_multiple_cycles() {
+        let mut graph = HashMap::new();
+        graph.insert("C1".to_string(), vec!["C2".to_string()]);
+        graph.insert("C2".to_string(), vec!["C1".to_string()]);
+        graph.insert("D1".to_string(), vec!["D2".to_string()]);
+        graph.insert("D2".to_string(), vec!["D1".to_string()]);
+
+        let err = topological_sort(&graph).unwrap_err();
+        assert_eq!(err.len(), 2);
+    }
+
+    #[test]
+    fn test_cycle_with_dag() {
+        // Mixed: DAG part + cycle
+        let mut graph = HashMap::new();
+        graph.insert("Start".to_string(), vec!["CycleA".to_string()]);
+        graph.insert("CycleA".to_string(), vec!["CycleB".to_string()]);
+        graph.insert("CycleB".to_string(), vec!["CycleA".to_string()]);
+        graph.insert("End".to_string(), vec![]);
+
+        let err = topological_sort(&graph).unwrap_err();
+        assert_eq!(err.len(), 2);
+        assert!(err.contains(&"CycleA".to_string()));
+        assert!(err.contains(&"CycleB".to_string()));
+    }
+
+    #[test]
+    fn test_complex_dag_multiple_paths() {
+        let mut graph = HashMap::new();
+        graph.insert("T1".to_string(), vec!["T2".to_string(), "T3".to_string()]);
+        graph.insert("T2".to_string(), vec!["T4".to_string()]);
+        graph.insert("T3".to_string(), vec!["T4".to_string(), "T5".to_string()]);
+        graph.insert("T4".to_string(), vec!["T6".to_string()]);
+        graph.insert("T5".to_string(), vec!["T6".to_string()]);
+        graph.insert("T6".to_string(), vec![]);
+
+        let result = topological_sort(&graph).unwrap();
+        assert_eq!(result.len(), 6);
+        assert!(is_valid_topo_order(&result, &graph));
+    }
+
+    #[test]
+    fn test_no_duplicate_edges() {
+        let mut graph = HashMap::new();
+        graph.insert(
+            "DupA".to_string(),
+            vec!["DupB".to_string(), "DupB".to_string()],
+        ); // Dup edge
+        graph.insert("DupB".to_string(), vec![]);
+
+        let result = topological_sort(&graph).unwrap();
+        assert_eq!(result.len(), 2);
+        assert!(is_valid_topo_order(&result, &graph));
+    }
+
+    #[test]
+    fn test_long_chain() {
+        let mut graph = HashMap::new();
+        let nodes = (0..10).map(|i| format!("N{}", i)).collect::<Vec<_>>();
+        for i in 0..9 {
+            graph.insert(nodes[i].clone(), vec![nodes[i + 1].clone()]);
+        }
+        graph.insert(nodes[9].clone(), vec![]);
+
+        let result = topological_sort(&graph).unwrap();
+        assert_eq!(result.len(), 10);
+        for i in 0..9 {
+            let pos_i = result.iter().position(|n| n == &nodes[i]).unwrap();
+            let pos_next = result.iter().position(|n| n == &nodes[i + 1]).unwrap();
+            assert!(pos_i < pos_next);
+        }
+    }
+
+    #[test]
+    fn test_isolated_nodes_multiple() {
+        let mut graph = HashMap::new();
+        graph.insert("Iso1".to_string(), vec![]);
+        graph.insert("Iso2".to_string(), vec![]);
+        graph.insert("Iso3".to_string(), vec![]);
+
+        let result = topological_sort(&graph).unwrap();
+        assert_eq!(result.len(), 3);
+    }
+}
+```