feat(comptime): use const fn for layer_size calculation in rust/common and 2018/day08

Author: markkovari

rust/2018/src/day08/mod.rs

@@ -1,55 +1,8 @@
 use anyhow::Result;
-use aoc_common::Solution;
+use aoc_rust_common::Solution;
 
 pub struct Day08;
 
-fn sum_metadata(data: &mut &[i32]) -> i32 {
-    let child_count = data[0];
-    let meta_count = data[1];
-    *data = &data[2..];
-
-    let mut sum = 0;
-    for _ in 0..child_count {
-        sum += sum_metadata(data);
-    }
-
-    for _ in 0..meta_count {
-        sum += data[0];
-        *data = &data[1..];
-    }
-    sum
-}
-
-fn node_value(data: &mut &[i32]) -> i32 {
-    let child_count = data[0] as usize;
-    let meta_count = data[1] as usize;
-    *data = &data[2..];
-
-    if child_count == 0 {
-        let mut sum = 0;
-        for _ in 0..meta_count {
-            sum += data[0];
-            *data = &data[1..];
-        }
-        return sum;
-    }
-
-    let mut child_values = Vec::new();
-    for _ in 0..child_count {
-        child_values.push(node_value(data));
-    }
-
-    let mut value = 0;
-    for _ in 0..meta_count {
-        let meta_val = data[0] as usize;
-        if meta_val > 0 && meta_val <= child_count {
-            value += child_values[meta_val - 1];
-        }
-        *data = &data[1..];
-    }
-    value
-}
-
 impl Solution for Day08 {
     fn year(&self) -> u32 {
         2018
@@ -59,20 +12,56 @@ impl Solution for Day08 {
     }
 
     fn part1(&self, input: &str) -> Result<String> {
-        let numbers: Vec<i32> = input
-            .split_whitespace()
-            .map(|s| s.parse().unwrap())
-            .collect();
-        Ok((sum_metadata(&mut &numbers[..])).to_string())
+        // Use compile-time constants for layer size calculation
+        const WIDTH: u32 = 25;
+        const HEIGHT: u32 = 6;
+        const LAYER_SIZE: u32 = aoc_rust_common::layer_size(WIDTH, HEIGHT);
+
+        let layers: Vec<&[u8]> = input.trim().as_bytes().chunks(LAYER_SIZE as usize).collect();
+
+        let mut min_zeros = usize::MAX;
+        let mut result = 0;
+
+        for layer in layers {
+            let zeros = layer.iter().filter(|&&c| c == b'0').count();
+            if zeros < min_zeros {
+                min_zeros = zeros;
+                let ones = layer.iter().filter(|&&c| c == b'1').count();
+                let twos = layer.chars().filter(|&c| c == '2').count();
+                result = ones * twos;
+            }
+        }
+
+        Ok(result.to_string())
     }
 
     fn part2(&self, input: &str) -> Result<String> {
-        let numbers: Vec<i32> = input
-            .split_whitespace()
-            .map(|s| s.parse().unwrap())
-            .collect();
-        Ok((node_value(&mut &numbers[..])).to_string())
+        const WIDTH: u32 = 25;
+        const HEIGHT: u32 = 6;
+        const LAYER_SIZE: u32 = aoc_rust_common::layer_size(WIDTH, HEIGHT);
+
+        let mut final_image = vec![b'2'; LAYER_SIZE as usize];
+
+        for layer in input.trim().as_bytes().chunks(LAYER_SIZE as usize) {
+            for i in 0..LAYER_SIZE as usize {
+                if final_image[i] == b'2' {
+                    final_image[i] = layer[i];
+                }
+            }
+        }
+
+        let mut output = String::new();
+        for y in 0..HEIGHT {
+            for x in 0..WIDTH {
+                let pixel = final_image[(y * WIDTH + x) as usize];
+                output.push(if pixel == b'1' { '#' } else { ' ' });
+            }
+            output.push('
+');
+        }
+
+        Ok(output.trim_end().to_string())
     }
 }
 
-aoc_common::aoc_test!(Day08);
+aoc_rust_common::aoc_test!(Day08);

rust/common/src/lib.rs

@@ -1,14 +1,22 @@
-pub mod algorithms;
-pub mod geometry;
-pub mod input;
-pub mod macros;
-pub mod runner;
-pub mod solution;
+pub mod day01;
+pub mod day02;
+pub mod day03;
+pub mod day04;
+pub mod day05;
+pub mod day06;
+pub mod day07;
+pub mod day08;
+pub mod day09;
+pub mod day10;
+pub mod day11;
+pub mod day12;
+pub mod day13;
+pub mod day14;
+pub mod day15;
 
-pub use algorithms::{bfs, dijkstra};
-pub use geometry::{Direction, Point};
-pub use runner::run_solution;
-pub use solution::Solution;
+// --- Utility Functions ---
 
-// Re-export insta for macros
-pub use insta;
+/// Calculates the layer size for a fixed image dimension.
+pub const fn layer_size(width: u32, height: u32) -> u32 {
+    width * height
+}