feat: add tree-traversal, longest-word, and dict-resolve challenges

Turn three draft exercises into standalone cargo packages with idiomatic
typing, tests, and doc comments explaining the type choices:

- tree-traversal: Option<Box<Node>> for owned, sized recursive children
- longest-word: Option<&str> return with explicit borrow lifetimes
- dict-resolve: enum for number-or-reference values, cycle detection via seen set

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: 1995parham

README.md

@@ -213,6 +213,24 @@ This application receives a delimiter and some entries
 (i.e. some text files or array of strings) and after separation based on a delimiter,
 it will count and calculate the number of each word in the entries.
 
+### Tree Traversal 🌳
+
+Traverses a binary tree in pre-order, in-order, and post-order.
+The node structure stores each child as an `Option<Box<Node>>`,
+so `None` marks an empty subtree and the recursive type keeps a known size.
+
+### Longest Word 📏
+
+Given a `&str`, returns its longest whitespace-separated word,
+plus a variant that returns the longest word across two strings.
+It is a small exercise in lifetimes: the returned slice borrows from the input.
+
+### Dict Resolve 🔗
+
+Retrieves the numeric value for a key from a dictionary where a value is
+either a number or a reference to another key (e.g. deployment-stage timeouts).
+Reference chains can form cycles, so visited keys are tracked to avoid looping forever.
+
 ### Data in Depth
 
 This example is based on _Rust in Action_ book and shows how data is stored.

dict-resolve/.gitignore

@@ -0,0 +1 @@
+/target

dict-resolve/Cargo.toml

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

dict-resolve/src/main.rs

@@ -0,0 +1,104 @@
+//! Retrieve the numeric value for a key from a dictionary where a value is
+//! either a number or a *reference* to another key.
+//!
+//! Type choices:
+//! - Rust has no `String | i32` union type, so "number or reference" is a
+//!   tagged `enum Value`. `match` on it is exhaustive and checked at compile
+//!   time — replacing the draft's runtime `type(val) == "String"` test.
+//! - Visited keys are a `HashSet<String>` (one type parameter — the element),
+//!   not the draft's `HashSet<String, bool>`; a set already answers "seen it?".
+//! - `resolve` returns `Option<i64>`: `None` covers both a missing key and a
+//!   reference cycle (`local -> default -> local`) that never reaches a number.
+
+use std::collections::{HashMap, HashSet};
+
+/// A dictionary entry: a concrete number, or a pointer to another key.
+/// Encodes the draft's `String | i32` as a proper sum type.
+#[derive(Debug, Clone)]
+enum Value {
+    Num(i64),
+    Ref(String),
+}
+
+/// Resolve `key` to its numeric value, following references transitively.
+///
+/// Returns `None` when the key is missing, or when the reference chain forms a
+/// cycle and therefore never bottoms out at a number.
+fn resolve(map: &HashMap<String, Value>, key: &str) -> Option<i64> {
+    let mut seen = HashSet::new();
+    let mut current = key;
+
+    loop {
+        // A key we've already visited means we're going in circles.
+        if !seen.insert(current.to_string()) {
+            return None;
+        }
+
+        match map.get(current)? {
+            Value::Num(n) => return Some(*n),
+            Value::Ref(next) => current = next,
+        }
+    }
+}
+
+fn main() {
+    // Timeout (seconds) per deployment stage; some stages point at another.
+    let config = HashMap::from([
+        ("prod".to_string(), Value::Num(2)),
+        ("test".to_string(), Value::Num(5)),
+        ("local".to_string(), Value::Ref("default".to_string())),
+        ("default".to_string(), Value::Ref("local".to_string())),
+        ("staging".to_string(), Value::Ref("test".to_string())),
+    ]);
+
+    for key in ["prod", "test", "staging", "local", "missing"] {
+        println!("{key:>8} -> {:?}", resolve(&config, key));
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn config() -> HashMap<String, Value> {
+        HashMap::from([
+            ("prod".to_string(), Value::Num(2)),
+            ("test".to_string(), Value::Num(5)),
+            ("local".to_string(), Value::Ref("default".to_string())),
+            ("default".to_string(), Value::Ref("local".to_string())),
+            ("staging".to_string(), Value::Ref("test".to_string())),
+        ])
+    }
+
+    #[test]
+    fn direct_number() {
+        assert_eq!(resolve(&config(), "prod"), Some(2));
+        assert_eq!(resolve(&config(), "test"), Some(5));
+    }
+
+    #[test]
+    fn single_reference() {
+        assert_eq!(resolve(&config(), "staging"), Some(5));
+    }
+
+    #[test]
+    fn cyclic_reference_returns_none() {
+        assert_eq!(resolve(&config(), "local"), None);
+        assert_eq!(resolve(&config(), "default"), None);
+    }
+
+    #[test]
+    fn missing_key_returns_none() {
+        assert_eq!(resolve(&config(), "missing"), None);
+    }
+
+    #[test]
+    fn longer_chain() {
+        let map = HashMap::from([
+            ("a".to_string(), Value::Ref("b".to_string())),
+            ("b".to_string(), Value::Ref("c".to_string())),
+            ("c".to_string(), Value::Num(42)),
+        ]);
+        assert_eq!(resolve(&map, "a"), Some(42));
+    }
+}

longest-word/.gitignore

@@ -0,0 +1 @@
+/target

longest-word/Cargo.toml

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

longest-word/src/main.rs

@@ -0,0 +1,85 @@
+//! Given a `&str`, return its longest whitespace-separated word.
+//!
+//! Type choices:
+//! - Returns `Option<&str>`, not `&str`. The result is a *slice into the
+//!   input*, and empty/whitespace-only input has no longest word — `None`
+//!   makes that a type-level outcome instead of panicking on `words[0]`.
+//! - No intermediate `Vec<&str>`: `split_whitespace()` yields an iterator we
+//!   reduce directly with `max_by_key`.
+
+/// Longest word in a single string. Ties resolve to the last such word
+/// (`max_by_key` keeps the last maximum).
+fn longest_word(s: &str) -> Option<&str> {
+    s.split_whitespace().max_by_key(|word| word.len())
+}
+
+/// Longest word across two strings.
+///
+/// The `'a` lifetime is the point of this signature: the returned slice borrows
+/// from *one of* the inputs, so both `s1` and `s2` must share `'a` and outlive
+/// the result. Writing `-> &str` with no `'a` (as the draft did) wouldn't
+/// compile — the compiler can't infer which input the borrow comes from.
+fn longest_word_couple<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
+    [longest_word(s1), longest_word(s2)]
+        .into_iter()
+        .flatten()
+        .max_by_key(|word| word.len())
+}
+
+fn main() {
+    let sentence = "the quick brown fox jumped";
+    println!("longest in {sentence:?} -> {:?}", longest_word(sentence));
+
+    let a = "a lazy dog";
+    let b = "an energetic caterpillar";
+    println!(
+        "longest across {a:?} and {b:?} -> {:?}",
+        longest_word_couple(a, b)
+    );
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn picks_longest() {
+        assert_eq!(longest_word("the quick brownish fox"), Some("brownish"));
+    }
+
+    #[test]
+    fn ties_resolve_to_last() {
+        // "quick" and "brown" are both 5 chars; max_by_key keeps the last.
+        assert_eq!(longest_word("the quick brown fox"), Some("brown"));
+    }
+
+    #[test]
+    fn single_word() {
+        assert_eq!(longest_word("hello"), Some("hello"));
+    }
+
+    #[test]
+    fn empty_and_whitespace() {
+        assert_eq!(longest_word(""), None);
+        assert_eq!(longest_word("   \t\n "), None);
+    }
+
+    #[test]
+    fn ignores_extra_whitespace() {
+        assert_eq!(longest_word("  a   bb  ccc "), Some("ccc"));
+    }
+
+    #[test]
+    fn couple_picks_global_longest() {
+        assert_eq!(
+            longest_word_couple("a lazy dog", "an energetic caterpillar"),
+            Some("caterpillar")
+        );
+    }
+
+    #[test]
+    fn couple_handles_one_empty_side() {
+        assert_eq!(longest_word_couple("", "solo"), Some("solo"));
+        assert_eq!(longest_word_couple("", ""), None);
+    }
+}

tree-traversal/.gitignore

@@ -0,0 +1 @@
+/target

tree-traversal/Cargo.toml

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

tree-traversal/src/main.rs

@@ -0,0 +1,145 @@
+//! Traverse a binary tree in in-order / pre-order / post-order.
+//!
+//! Type choices:
+//! - `val: i64` — Rust's 64-bit signed integer (the draft's `int64` isn't a
+//!   real type name).
+//! - Children are `Option<Box<Node>>`, not `Option<&Node>`. A `&Node` only
+//!   *borrows* a node owned elsewhere; a tree needs to *own* its children, and
+//!   `Box` is an owning heap pointer. `Box` is also required for the type to
+//!   exist at all: a `Node` holding a bare `Node` would be infinitely sized,
+//!   and the fixed-size `Box` pointer breaks that recursion.
+//! - `Option` distinguishes an empty subtree (`None`) from a present child.
+
+#[derive(Debug)]
+struct Node {
+    val: i64,
+    // `Box` owns the child on the heap; `Option` allows an absent subtree.
+    left: Option<Box<Node>>,
+    right: Option<Box<Node>>,
+}
+
+impl Node {
+    fn leaf(val: i64) -> Box<Node> {
+        Box::new(Node {
+            val,
+            left: None,
+            right: None,
+        })
+    }
+
+    fn new(val: i64, left: Option<Box<Node>>, right: Option<Box<Node>>) -> Box<Node> {
+        Box::new(Node { val, left, right })
+    }
+}
+
+/// Root, then left subtree, then right subtree.
+fn pre_order(root: &Option<Box<Node>>, out: &mut Vec<i64>) {
+    if let Some(node) = root {
+        out.push(node.val);
+        pre_order(&node.left, out);
+        pre_order(&node.right, out);
+    }
+}
+
+/// Left subtree, then root, then right subtree.
+fn in_order(root: &Option<Box<Node>>, out: &mut Vec<i64>) {
+    if let Some(node) = root {
+        in_order(&node.left, out);
+        out.push(node.val);
+        in_order(&node.right, out);
+    }
+}
+
+/// Left subtree, then right subtree, then root.
+fn post_order(root: &Option<Box<Node>>, out: &mut Vec<i64>) {
+    if let Some(node) = root {
+        post_order(&node.left, out);
+        post_order(&node.right, out);
+        out.push(node.val);
+    }
+}
+
+/// Small helper so callers don't have to allocate the output vector themselves.
+fn collect(root: &Option<Box<Node>>, order: fn(&Option<Box<Node>>, &mut Vec<i64>)) -> Vec<i64> {
+    let mut out = Vec::new();
+    order(root, &mut out);
+    out
+}
+
+fn main() {
+    //         1
+    //        / \
+    //       2   3
+    //      / \
+    //     4   5
+    let tree = Some(Node::new(
+        1,
+        Some(Node::new(2, Some(Node::leaf(4)), Some(Node::leaf(5)))),
+        Some(Node::leaf(3)),
+    ));
+
+    println!("pre-order:  {:?}", collect(&tree, pre_order));
+    println!("in-order:   {:?}", collect(&tree, in_order));
+    println!("post-order: {:?}", collect(&tree, post_order));
+
+    let empty: Option<Box<Node>> = None;
+    println!("empty:      {:?}", collect(&empty, in_order));
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn empty_tree_yields_nothing() {
+        let empty: Option<Box<Node>> = None;
+        assert!(collect(&empty, pre_order).is_empty());
+        assert!(collect(&empty, in_order).is_empty());
+        assert!(collect(&empty, post_order).is_empty());
+    }
+
+    #[test]
+    fn single_root() {
+        let tree = Some(Node::leaf(1));
+        assert_eq!(collect(&tree, pre_order), [1]);
+        assert_eq!(collect(&tree, in_order), [1]);
+        assert_eq!(collect(&tree, post_order), [1]);
+    }
+
+    #[test]
+    fn root_with_left_child() {
+        let tree = Some(Node::new(1, Some(Node::leaf(2)), None));
+        assert_eq!(collect(&tree, pre_order), [1, 2]);
+        assert_eq!(collect(&tree, in_order), [2, 1]);
+        assert_eq!(collect(&tree, post_order), [2, 1]);
+    }
+
+    #[test]
+    fn root_with_right_child() {
+        let tree = Some(Node::new(1, None, Some(Node::leaf(2))));
+        assert_eq!(collect(&tree, pre_order), [1, 2]);
+        assert_eq!(collect(&tree, in_order), [1, 2]);
+        assert_eq!(collect(&tree, post_order), [2, 1]);
+    }
+
+    #[test]
+    fn root_left_then_right() {
+        // root -> left -> right
+        let tree = Some(Node::new(1, Some(Node::new(2, None, Some(Node::leaf(3)))), None));
+        assert_eq!(collect(&tree, pre_order), [1, 2, 3]);
+        assert_eq!(collect(&tree, in_order), [2, 3, 1]);
+        assert_eq!(collect(&tree, post_order), [3, 2, 1]);
+    }
+
+    #[test]
+    fn full_tree() {
+        let tree = Some(Node::new(
+            1,
+            Some(Node::new(2, Some(Node::leaf(4)), Some(Node::leaf(5)))),
+            Some(Node::leaf(3)),
+        ));
+        assert_eq!(collect(&tree, pre_order), [1, 2, 4, 5, 3]);
+        assert_eq!(collect(&tree, in_order), [4, 2, 5, 1, 3]);
+        assert_eq!(collect(&tree, post_order), [4, 5, 2, 3, 1]);
+    }
+}