feat(06/2015): solve first part

Author: manhunto

readme.md

@@ -92,7 +92,7 @@
 | [Day 3: Perfectly Spherical Houses in a Vacuum](src/solutions/year2015/day03.rs) |   ⭐⭐   |            0.358 |            0.373 |
 | [Day 4: The Ideal Stocking Stuffer](src/solutions/year2015/day04.rs)             |   ⭐⭐   |           66.769 |         1931.428 |
 | [Day 5: Doesn't He Have Intern-Elves For This?](src/solutions/year2015/day05.rs) |   ⭐⭐   |            0.261 |            0.987 |
-| [Day 6: Probably a Fire Hazard](src/solutions/year2015/day06.rs)                 |        |                - |                - |
+| [Day 6: Probably a Fire Hazard](src/solutions/year2015/day06.rs)                 |   ⭐    |         1227.077 |                - |
 
 # TODO
 

src/solutions/year2015/day06.rs

@@ -1,23 +1,130 @@
 use crate::solutions::Solution;
+use crate::utils::grid::Grid;
+use crate::utils::point::Point;
+use crate::utils::surface_range::SurfaceRange;
+use std::fmt::Debug;
 
 pub struct Day06;
 
 impl Solution for Day06 {
-    fn part_one(&self, _input: &str) -> String {
-        String::from("0")
+    fn part_one(&self, input: &str) -> String {
+        let mut grid = Grid::filled(
+            SurfaceRange::from((Point::new(0, 0), Point::new(999, 999))),
+            false,
+        );
+        let instructions = self.parse(input);
+
+        for instruction in instructions {
+            instruction.apply(&mut grid);
+        }
+
+        grid.get_all_positions(&true).len().to_string()
     }
 
     fn part_two(&self, _input: &str) -> String {
         String::from("0")
     }
 }
 
+impl Day06 {
+    fn parse(&self, input: &str) -> Vec<Box<dyn Instruction>> {
+        input
+            .lines()
+            .map(|line| -> Box<dyn Instruction> {
+                if line.starts_with("turn on ") {
+                    let trimmed = line.trim_start_matches("turn on ");
+
+                    Box::new(TurnOn::from(self.parse_points(trimmed)))
+                } else if line.starts_with("turn off ") {
+                    let trimmed = line.trim_start_matches("turn off ");
+
+                    Box::new(TurnOff::from(self.parse_points(trimmed)))
+                } else if line.starts_with("toggle ") {
+                    let trimmed = line.trim_start_matches("toggle ");
+
+                    Box::new(Toggle::from(self.parse_points(trimmed)))
+                } else {
+                    unreachable!()
+                }
+            })
+            .collect()
+    }
+
+    fn parse_points(&self, points_str: &str) -> (Point, Point) {
+        let p = points_str.split_once(" through ").unwrap();
+
+        (p.0.parse().unwrap(), p.1.parse().unwrap())
+    }
+}
+
+trait Instruction: Debug {
+    fn apply(&self, grid: &mut Grid<bool>);
+}
+
+#[derive(Debug)]
+struct TurnOn {
+    surface_range: SurfaceRange,
+}
+
+impl From<(Point, Point)> for TurnOn {
+    fn from(value: (Point, Point)) -> Self {
+        Self {
+            surface_range: SurfaceRange::from(value),
+        }
+    }
+}
+
+impl Instruction for TurnOn {
+    fn apply(&self, grid: &mut Grid<bool>) {
+        grid.modify_many(self.surface_range.points(), true)
+    }
+}
+
+#[derive(Debug)]
+struct TurnOff {
+    surface_range: SurfaceRange,
+}
+
+impl From<(Point, Point)> for TurnOff {
+    fn from(value: (Point, Point)) -> Self {
+        Self {
+            surface_range: SurfaceRange::from(value),
+        }
+    }
+}
+
+impl Instruction for TurnOff {
+    fn apply(&self, grid: &mut Grid<bool>) {
+        grid.modify_many(self.surface_range.points(), false)
+    }
+}
+
+#[derive(Debug)]
+struct Toggle {
+    surface_range: SurfaceRange,
+}
+
+impl From<(Point, Point)> for Toggle {
+    fn from(value: (Point, Point)) -> Self {
+        Self {
+            surface_range: SurfaceRange::from(value),
+        }
+    }
+}
+
+impl Instruction for Toggle {
+    fn apply(&self, grid: &mut Grid<bool>) {
+        grid.modify_many_with(self.surface_range.points(), |b| *b = !*b)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
     fn part_one_example_test() {
-        assert_eq!("0", Day06.part_one(""));
+        assert_eq!("1000000", Day06.part_one("turn on 0,0 through 999,999"));
+        assert_eq!("1000", Day06.part_one("toggle 0,0 through 999,0"));
     }
 }

src/utils/grid.rs

@@ -46,7 +46,6 @@ where
         Self::new(cells)
     }
 
-    #[allow(dead_code)]
     pub fn filled(surface_range: SurfaceRange, element: T) -> Self
     where
         T: Clone,
@@ -178,7 +177,6 @@ where
         *self.cells.get_mut(&point).unwrap() = new_value;
     }
 
-    #[allow(dead_code)]
     pub fn modify_many(&mut self, points: Vec<Point>, new_value: T)
     where
         T: Clone,
@@ -188,6 +186,15 @@ where
         }
     }
 
+    pub fn modify_many_with<F>(&mut self, points: Vec<Point>, mut func: F)
+    where
+        F: FnMut(&mut T),
+    {
+        for point in points {
+            self.cells.entry(point).and_modify(&mut func);
+        }
+    }
+
     fn move_rows_to_south_from(&mut self, from: isize) {
         for y in self
             .rows_range

src/utils/surface_range.rs

@@ -85,6 +85,18 @@ impl SurfaceRange {
             y_range: self.y_range._shrink(by).unwrap(),
         }
     }
+
+    pub fn points(&self) -> Vec<Point> {
+        let mut points: Vec<Point> = Vec::with_capacity(self.area());
+
+        for x in self.columns().iter() {
+            for y in self.rows().iter() {
+                points.push(Point::new(x, y));
+            }
+        }
+
+        points
+    }
 }
 
 impl From<(Point, Point)> for SurfaceRange {