feat: Add fruit basket challenge

Author: Curstantine

src/challenge/challenge_02.rs

@@ -0,0 +1,159 @@
+//! Challenge 02: Fruit Basket Reorganization
+use anyhow::Result;
+use colored::Colorize;
+use std::collections::{BinaryHeap, HashMap};
+
+pub fn run(input: &str, output: Option<&str>) -> Result<String> {
+    let fruit_basket = input.trim();
+    let result = reorganize_fruit_basket(fruit_basket);
+
+    if let Some(expected_output) = output {
+        if result == expected_output {
+            return Ok(format!("Result '{}' matches the specified output.", result));
+        }
+
+        if is_valid_reorganization(&result) && expected_output != "impossible" {
+            return Ok(format!(
+                "Generated a valid reorganization '{result}', which is different from the provided sample '{expected_output}'."
+            ));
+        }
+
+        anyhow::bail!("Output '{result}' of '{input}' doesn't match expected '{expected_output}'.");
+    }
+
+    Ok(format!(
+        "Reorganized fruit basket to '{result}', but {} output!",
+        "missing".red().bold()
+    ))
+}
+
+fn is_valid_reorganization(s: &str) -> bool {
+    let mut chars = s.chars();
+    let mut prev = chars.next();
+
+    for current in chars {
+        if let Some(p) = prev {
+            if p == current {
+                return false;
+            }
+        }
+
+        prev = Some(current);
+    }
+
+    true
+}
+
+pub fn reorganize_fruit_basket(s: &str) -> String {
+    let mut counts = HashMap::new();
+    for c in s.chars() {
+        *counts.entry(c).or_insert(0) += 1;
+    }
+
+    if let Some((_, &max_freq)) = counts.iter().max_by_key(|&(_, count)| count) {
+        if max_freq > s.len().div_ceil(2) {
+            return "impossible".to_string();
+        }
+    }
+
+    let mut heap: BinaryHeap<(usize, char)> = BinaryHeap::new();
+    for (c, count) in counts {
+        heap.push((count, c));
+    }
+
+    let mut result = Vec::with_capacity(s.len());
+    let mut prev: Option<(usize, char)> = None;
+
+    while !heap.is_empty() {
+        let (count, char) = heap.pop().unwrap();
+        result.push(char);
+
+        if let Some(p) = prev {
+            if p.0 > 0 {
+                heap.push(p);
+            }
+        }
+
+        prev = Some((count - 1, char));
+    }
+
+    let final_string: String = result.iter().collect();
+
+    if !is_valid_reorganization(&final_string) {
+        return "impossible".to_string();
+    }
+
+    if final_string.len() != s.len() {
+        // This can happen if the last character pushed to prev has a count > 0
+        // but the loop terminates. This indicates impossibility that wasn't caught
+        // by the initial check, which can happen in some complex cases.
+        // However, the initial check should be sufficient for this problem.
+        // A more robust check would be to check if prev.0 > 0 after the loop.
+        if let Some(p) = prev {
+            if p.0 > 0 {
+                return "impossible".to_string();
+            }
+        }
+    }
+
+    final_string
+}
+
+#[cfg(test)]
+mod tests {
+    use super::reorganize_fruit_basket;
+
+    fn is_valid_reorganization(s: &str) -> bool {
+        if s == "impossible" {
+            return true;
+        }
+
+        super::is_valid_reorganization(s)
+    }
+
+    #[test]
+    fn test_sample_input() {
+        let input = "aapplle";
+        let result = reorganize_fruit_basket(input);
+        assert!(is_valid_reorganization(&result));
+        assert_ne!(result, "impossible");
+    }
+
+    #[test]
+    fn test_impossible_case() {
+        let input = "aaab";
+        assert_eq!(reorganize_fruit_basket(input), "impossible");
+    }
+
+    #[test]
+    fn test_all_same_fruit() {
+        let input = "aaaaa";
+        assert_eq!(reorganize_fruit_basket(input), "impossible");
+    }
+
+    #[test]
+    fn test_possible_case() {
+        let input = "aaabbc";
+        let result = reorganize_fruit_basket(input);
+        assert!(is_valid_reorganization(&result));
+        assert_ne!(result, "impossible");
+    }
+
+    #[test]
+    fn test_empty_string() {
+        let input = "";
+        assert_eq!(reorganize_fruit_basket(input), "");
+    }
+
+    #[test]
+    fn test_single_char() {
+        let input = "a";
+        assert_eq!(reorganize_fruit_basket(input), "a");
+    }
+
+    #[test]
+    fn test_long_string() {
+        let input = "vvvlo";
+        assert_eq!(reorganize_fruit_basket(input), "impossible");
+    }
+}

src/challenge/mod.rs

@@ -1,16 +1,18 @@
 mod challenge_01;
+mod challenge_02;
 
 pub fn name(challenge: &str) -> Option<&'static str> {
     match challenge {
-        "01" => Some("Balanced Meal Pair"),
-        "02" => Some("Research Lab Recorder"),
+        "01" => Some("Research Lab Recorder"),
+        "02" => Some("Fruit Basket Reorganization"),
         _ => None,
     }
 }
 
 pub fn run(challenge: &str, input: &str, output: Option<&str>) -> anyhow::Result<String> {
     match challenge {
         "01" => challenge_01::run(input, output),
+        "02" => challenge_02::run(input, output),
         _ => anyhow::bail!("Error: Unknown challenge '{challenge}'"),
     }
 }

testcases/02/01_input.txt

@@ -0,0 +1 @@
+vovlv

testcases/02/01_output.txt

@@ -0,0 +1 @@
+impossible