day14 problem 2 solution

14/src/main.rs

@@ -1,7 +1,8 @@
+use std::collections::HashMap;
 use std::fmt::{Display, Write};
 use std::fs::File;
 use std::io::{BufRead, BufReader, Lines};
-use std::time::{Duration, Instant};
+use std::time::Instant;
 
 // BOILERPLATE
 type InputIter = Lines<BufReader<File>>;
@@ -26,16 +27,24 @@ fn main() {
 
 // PARSE
 
-struct Platform(Vec<Vec<char>>);
+#[derive(Debug)]
+struct Platform {
+    rows: Vec<Vec<char>>,
+}
 
 impl<T: BufRead> From<Lines<T>> for Platform {
     fn from(lines: Lines<T>) -> Self {
-        Self(lines.map(|line| line.unwrap().chars().collect()).collect())
+        Self {
+            rows: lines.map(|line| line.unwrap().chars().collect()).collect(),
+        }
     }
 }
 
 enum Direction {
     North,
+    South,
+    East,
+    West,
 }
 
 #[derive(Debug, PartialEq)]
@@ -47,26 +56,31 @@ enum Axis {
 impl Direction {
     fn reverse_direction(&self) -> bool {
         match self {
-            Direction::North => false,
+            Direction::North | Direction::West => false,
+            Direction::South | Direction::East => true,
         }
     }
     fn axis(&self) -> Axis {
         match self {
-            Direction::North => Axis::Columns,
+            Direction::North | Direction::South => Axis::Columns,
+            Direction::East | Direction::West => Axis::Rows,
         }
     }
 }
 
 impl<'a> Platform {
     fn width(&self) -> usize {
-        self.0[0].len()
+        self.rows[0].len()
+    }
+    fn height(&self) -> usize {
+        self.col(0).len()
     }
     fn col(&self, col: usize) -> Vec<char> {
-        self.0.iter().map(|row| row[col]).collect()
+        self.rows.iter().map(|row| row[col]).collect()
     }
     fn replace_col(&mut self, idx: usize, col: Vec<char>) {
         for row_idx in 0..col.len() {
-            self.0[row_idx][idx] = col[row_idx];
+            self.rows[row_idx][idx] = col[row_idx];
         }
     }
     fn roll(&mut self, dir: &Direction) {
@@ -88,9 +102,30 @@ impl<'a> Platform {
             self.roll_column(col, dir);
         }
     }
+    // This code could definitely be reused for rows
     fn roll_column(&mut self, idx: usize, dir: &Direction) {
         let mut col = self.col(idx);
-        // TODO: implement reverse direction
+        if dir.reverse_direction() {
+            for col_idx in (0..col.len()).rev() {
+                match col[col_idx] {
+                    '.' | '#' => continue,
+                    'O' if col_idx == col.len() => continue,
+                    'O' => {
+                        // Find the first # rock or the edge of the map, we can't look beyond this for a resting position
+                        let upper_limit = (col_idx..col.len())
+                            .find(|c| col[*c] == '#')
+                            .unwrap_or(col.len());
+
+                        if let Some(empty_pos) =
+                            (col_idx..upper_limit).filter(|i| col[*i] == '.').last()
+                        {
+                            col.swap(col_idx, empty_pos);
+                        }
+                    }
+                    _ => panic!("invalid character"),
+                }
+            }
+        } else {
             for col_idx in 0..col.len() {
                 match col[col_idx] {
                     '.' | '#' => continue,
@@ -110,19 +145,90 @@ impl<'a> Platform {
                     _ => panic!("invalid character"),
                 }
             }
+        }
         self.replace_col(idx, col);
     }
     fn score_columns(&self, dir: &Direction) -> u64 {
-        // TODO: implement reverse direction
+        // TODO: implement reverse direction - this was not required for the problem
-        (0..self.0.len())
+        (0..self.rows.len())
             .map(|row| {
-                let row_score = self.0.len() - row;
+                let row_score = self.rows.len() - row;
-                self.0[row].iter().filter(|c| **c == 'O').count() * row_score
+                self.rows[row].iter().filter(|c| **c == 'O').count() * row_score
             })
             .sum::<usize>() as u64
     }
-    fn roll_rows(&self, dir: &Direction) {
+    fn roll_rows(&mut self, dir: &Direction) {
-        unimplemented!()
+        assert_eq!(dir.axis(), Axis::Rows);
+
+        for row in 0..self.height() {
+            self.roll_row(row, dir);
+        }
+    }
+    fn roll_row(&mut self, idx: usize, dir: &Direction) {
+        let mut row = self.rows[idx].clone();
+        if dir.reverse_direction() {
+            for row_idx in (0..row.len()).rev() {
+                match row[row_idx] {
+                    '.' | '#' => continue,
+                    'O' if row_idx == row.len() => continue,
+                    'O' => {
+                        // Find the first # rock or the edge of the map, we can't look beyond this for a resting position
+                        let upper_limit = (row_idx..row.len())
+                            .find(|c| row[*c] == '#')
+                            .unwrap_or(row.len());
+
+                        if let Some(empty_pos) =
+                            (row_idx..upper_limit).filter(|i| row[*i] == '.').last()
+                        {
+                            row.swap(row_idx, empty_pos);
+                        }
+                    }
+                    _ => panic!("invalid character"),
+                }
+            }
+        } else {
+            for row_idx in 0..row.len() {
+                match row[row_idx] {
+                    '.' | '#' => continue,
+                    'O' if row_idx == 0 => continue,
+                    'O' => {
+                        // Find the first # rock or the edge of the map, we can't look beyond this for a resting position
+                        let lower_limit = (0..row_idx).rev().find(|c| row[*c] == '#').unwrap_or(0);
+
+                        if let Some(empty_pos) = (lower_limit..row_idx)
+                            .rev()
+                            .filter(|i| row[*i] == '.')
+                            .last()
+                        {
+                            row.swap(row_idx, empty_pos);
+                        }
+                    }
+                    _ => panic!("invalid character"),
+                }
+            }
+        }
+        self.rows[idx] = row;
+    }
+
+    fn roll_cycle(&mut self) {
+        self.roll(&Direction::North);
+        self.roll(&Direction::West);
+        self.roll(&Direction::South);
+        self.roll(&Direction::East);
+    }
+
+    // find the first loop, return the iteration count when we first saw it and when we saw it again
+    fn find_loop(&mut self) -> (usize, usize) {
+        let mut first_seen: HashMap<Vec<Vec<char>>, usize> = HashMap::new();
+        first_seen.insert(self.rows.clone(), 0);
+        let mut i = 0;
+        loop {
+            self.roll_cycle();
+            i += 1;
+            if let Some(first_idx) = first_seen.insert(self.rows.clone(), i) {
+                return (first_idx, i);
+            }
+        }
     }
     fn score_rows(&self, dir: &Direction) -> u64 {
         unimplemented!()
@@ -131,7 +237,7 @@ impl<'a> Platform {
 
 impl Display for Platform {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        for row in &self.0 {
+        for row in &self.rows {
             for c in row {
                 f.write_char(*c)?;
             }
@@ -151,7 +257,17 @@ fn problem1<T: BufRead>(input: Lines<T>) -> u64 {
 
 // PROBLEM 2 solution
 fn problem2<T: BufRead>(input: Lines<T>) -> u64 {
-    0
+    const ITERATIONS: usize = 1000000000;
+    let mut p = Platform::from(input);
+    let first_loop = p.find_loop();
+    let loop_length = first_loop.1 - first_loop.0;
+    let cycles_to_skip = ((ITERATIONS - first_loop.0) / loop_length) * loop_length;
+    let iterations_remaining = ITERATIONS - first_loop.0 - cycles_to_skip;
+    for _ in 0..iterations_remaining {
+        p.roll_cycle();
+    }
+
+    p.score(&Direction::North)
 }
 
 #[cfg(test)]
@@ -179,6 +295,6 @@ O.#..O.#.#
     #[test]
     fn problem2_example() {
         let c = Cursor::new(EXAMPLE);
-        assert_eq!(problem2(c.lines()), 0);
+        assert_eq!(problem2(c.lines()), 64);
     }
 }