Day 2 Part 2

day_02/src/lib.rs

@@ -1,4 +1,4 @@
-use std::fmt::{Debug, Formatter};
+use std::fmt::Debug;
 
 peg::parser!{
     grammar input_parser() for str {
@@ -29,14 +29,14 @@ pub(crate) enum Direction {
     Up(usize),
 }
 
-pub(crate) struct Submarine {
+pub(crate) struct SubmarinePart1 {
     horizontal: usize,
     depth: usize,
 }
 
-impl Submarine {
+impl SubmarinePart1 {
     fn new() -> Self {
-        Submarine {
+        Self {
             horizontal: 0,
             depth: 0,
         }
@@ -52,6 +52,32 @@ impl Submarine {
     }
 }
 
+pub(crate) struct SubmarinePart2 {
+    horizontal: usize,
+    depth: usize,
+    aim: usize
+}
+
+impl SubmarinePart2 {
+    fn new() -> Self {
+        Self {
+            horizontal: 0,
+            depth: 0,
+            aim: 0,
+        }
+    }
+    fn move_in_direction(&mut self, direction: &Direction) -> () {
+        match direction {
+            Direction::Forward(x) => {
+                self.horizontal += x;
+                self.depth += self.aim * x
+            },
+            Direction::Up(y) => self.aim -= y,
+            Direction::Down(y) => self.aim += y,
+        }
+    }
+}
+
 pub(crate) fn input_parse(input: &str) -> Vec<Direction> {
     input_parser::directions(input).unwrap()
 }
@@ -95,7 +121,7 @@ pub(crate) fn input_parse(input: &str) -> Vec<Direction> {
 /// Calculate the horizontal position and depth you would have after following the planned course. What do you get if you multiply your final horizontal position by your final depth?
 pub fn part1(input: &str) -> usize {
     let directions = input_parse(input);
-    let mut p = Submarine::new();
+    let mut p = SubmarinePart1::new();
     directions.iter().for_each(|direction| p.move_in_direction(direction));
     p.horizontal * p.depth
 }
@@ -131,5 +157,8 @@ pub fn part1(input: &str) -> usize {
 ///
 /// Using this new interpretation of the commands, calculate the horizontal position and depth you would have after following the planned course. What do you get if you multiply your final horizontal position by your final depth?
 pub fn part2(input: &str) -> usize {
-    0
+    let directions = input_parse(input);
+    let mut p = SubmarinePart2::new();
+    directions.iter().for_each(|direction| p.move_in_direction(direction));
+    p.depth * p.horizontal
 }

src/main.rs

@@ -39,6 +39,7 @@ fn main() -> Result<(), Box<dyn Error>> {
         (DaysImplemented::Day1, 1) => println!("{}", day_01::part1(&input)),
         (DaysImplemented::Day1, 2) => println!("{}", day_01::part2(&input)),
         (DaysImplemented::Day2, 1) => println!("{}", day_02::part1(&input)),
+        (DaysImplemented::Day2, 2) => println!("{}", day_02::part2(&input)),
         _ => {unimplemented!()}
     };