chore: remove the first question and swap

Author: Curstantine

src/challenge/challenge_01.rs

@@ -1,118 +1,109 @@
-//! Challenge 01: Balanced Meal Pair
-use std::collections::HashMap;
-
+//! Challenge 01: Research Lab Recorder
+use anyhow::Result;
 use colored::Colorize;
 
-use crate::utils::split_whitespace_and_parse;
-
-pub fn run(input: &str, output: Option<&str>) -> anyhow::Result<String> {
-    let lines: Vec<&str> = input.trim().lines().collect();
-    let outputs = output.map(split_whitespace_and_parse::<u16>).transpose()?;
+use crate::utils::{VecPreview, split_whitespace_and_parse};
 
-    anyhow::ensure!(lines.len() == 2, "Invalid input format");
+pub fn run(input: &str, output: Option<&str>) -> Result<String> {
+    let mut lines = input.lines();
+    let n: u16 = lines.next().unwrap().trim().parse()?;
 
-    let target = lines[0].parse()?;
-    let meals = split_whitespace_and_parse(lines[1])?;
+    let readings: Vec<u16> = split_whitespace_and_parse(lines.next().unwrap())?;
+    anyhow::ensure!(readings.len() == n.into(), "Input length does not match n");
 
-    match find_balanced_meal_pair(&meals, target) {
-        Some((i, j)) => {
-            if let Some(outputs) = outputs {
-                anyhow::ensure!(outputs.len() == 2, "Invalid output format");
-                anyhow::ensure!(
-                    (i == outputs[0] && j == outputs[1]) || (i == outputs[1] && j == outputs[0]),
-                    "Indices do not match: expected ({}, {}) got ({i}, {j})",
-                    outputs[0],
-                    outputs[1],
-                );
+    let result = next_higher_readings(&readings);
 
-                return Ok(format!("Pair matches outputs at indices ({}, {})", i, j));
-            }
-
-            Ok(format!(
-                "Pair found at indices ({i}, {j}), but {} output!",
-                "missing".red().bold()
-            ))
-        }
-        None => anyhow::bail!("No suitable pair found"),
-    }
-}
+    if let Some(output) = output.map(split_whitespace_and_parse::<u16>).transpose()? {
+        anyhow::ensure!(
+            result == output,
+            "Output vector does not match expected: got '{:?}' expected '{:?}'",
+            result,
+            output
+        );
 
-fn find_balanced_meal_pair(meals: &[u16], target: u16) -> Option<(u16, u16)> {
-    if meals.len() < 2 {
-        return None;
+        return Ok(format!(
+            "Result matches the specified output: {}",
+            result.preview(15)
+        ));
     }
 
-    let mut seen = HashMap::new();
-    let mut best_pair = None::<(u16, u16)>;
-    let mut best_diff = u16::MAX;
-
-    for (i, &meal) in meals.iter().enumerate() {
-        let (complement, overflowing) = target.overflowing_sub(meal);
-
-        if overflowing {
-            continue;
-        }
-
-        if let Some(&j) = seen.get(&complement) {
-            let diff = (meal + complement).abs_diff(target);
-            if diff < best_diff {
-                best_diff = diff;
-                best_pair = Some((j, i as u16));
-            }
-        }
+    Ok(format!(
+        "Calculated the next higher reading of {result:?}, but {} output!",
+        "missing".red().bold()
+    ))
+}
 
-        for (&prev_meal, &prev_idx) in seen.iter() {
-            let sum: u16 = meal + prev_meal;
-            let diff = sum.abs_diff(target);
-            if diff < best_diff {
-                best_diff = diff;
-                best_pair = Some((prev_idx, i as u16));
+pub fn next_higher_readings(readings: &[u16]) -> Vec<u16> {
+    let n = readings.len();
+    let mut result = vec![0; n];
+    let mut stack: Vec<usize> = Vec::new();
+
+    for (i, &reading) in readings.iter().enumerate() {
+        while let Some(&last) = stack.last() {
+            if reading > readings[last] {
+                result[last] = (i - last) as u16;
+                stack.pop();
+            } else {
+                break;
             }
         }
-
-        seen.insert(meal, i as u16);
+        stack.push(i);
     }
 
-    best_pair
+    result
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
-    fn test_duplicate_values() {
-        let meals = [200, 200, 300];
-        assert_eq!(find_balanced_meal_pair(&meals, 400), Some((0, 1)));
+    fn test_sample_input_1() {
+        let readings = vec![30, 38, 30, 36, 35, 40, 28];
+        let expected = vec![1, 4, 1, 2, 1, 0, 0];
+        assert_eq!(next_higher_readings(&readings), expected);
     }
 
     #[test]
-    fn test_large_difference() {
-        let meals = [1, 2, 1000];
-        assert_eq!(find_balanced_meal_pair(&meals, 500), Some((0, 1)));
+    fn test_sample_input_2() {
+        let readings = vec![22, 21, 20];
+        let expected = vec![0, 0, 0];
+        assert_eq!(next_higher_readings(&readings), expected);
     }
 
     #[test]
-    fn test_exact_match() {
-        let meals = [150, 400, 200, 350];
-        assert_eq!(find_balanced_meal_pair(&meals, 600), Some((1, 2)));
+    fn test_all_increasing() {
+        let readings = vec![1, 2, 3, 4, 5];
+        let expected = vec![1, 1, 1, 1, 0];
+        assert_eq!(next_higher_readings(&readings), expected);
     }
 
     #[test]
-    fn test_closest_match() {
-        let meals = [100, 200, 300, 400];
-        assert_eq!(find_balanced_meal_pair(&meals, 550), Some((1, 2)));
+    fn test_all_equal() {
+        let readings = vec![10, 10, 10, 10];
+        let expected = vec![0, 0, 0, 0];
+        assert_eq!(next_higher_readings(&readings), expected);
     }
 
     #[test]
-    fn test_empty_array() {
-        let meals = [];
-        assert_eq!(find_balanced_meal_pair(&meals, 600), None);
+    fn test_single_element() {
+        let readings = vec![42];
+        let expected = vec![0];
+        assert_eq!(next_higher_readings(&readings), expected);
     }
 
     #[test]
-    fn test_single_element() {
-        let meals = [300];
-        assert_eq!(find_balanced_meal_pair(&meals, 600), None);
+    fn test_two_elements() {
+        let readings = vec![5, 10];
+        let expected = vec![1, 0];
+        assert_eq!(next_higher_readings(&readings), expected);
+    }
+
+    #[test]
+    fn test_large_case() {
+        let n = 1000; // Use a smaller n for practical test execution
+        let readings: Vec<u16> = (1..=n).rev().collect();
+        let expected = vec![0; n as usize];
+        assert_eq!(next_higher_readings(&readings), expected);
     }
 }

src/challenge/challenge_02.rs

@@ -1,5 +1,4 @@
 mod challenge_01;
-mod challenge_02;
 
 pub fn name(challenge: &str) -> Option<&'static str> {
     match challenge {
@@ -12,7 +11,6 @@ pub fn name(challenge: &str) -> Option<&'static str> {
 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}'"),
     }
 }