day14 problem 2 solution

This commit is contained in:
Keenan Tims 2023-12-13 23:29:03 -08:00
parent 11a7837400
commit e062ef5078
Signed by: ktims
GPG Key ID: 11230674D69038D4

View File

@ -1,7 +1,8 @@
use std::collections::HashMap;
use std::fmt::{Display, Write}; use std::fmt::{Display, Write};
use std::fs::File; use std::fs::File;
use std::io::{BufRead, BufReader, Lines}; use std::io::{BufRead, BufReader, Lines};
use std::time::{Duration, Instant}; use std::time::Instant;
// BOILERPLATE // BOILERPLATE
type InputIter = Lines<BufReader<File>>; type InputIter = Lines<BufReader<File>>;
@ -26,16 +27,24 @@ fn main() {
// PARSE // PARSE
struct Platform(Vec<Vec<char>>); #[derive(Debug)]
struct Platform {
rows: Vec<Vec<char>>,
}
impl<T: BufRead> From<Lines<T>> for Platform { impl<T: BufRead> From<Lines<T>> for Platform {
fn from(lines: Lines<T>) -> Self { 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 { enum Direction {
North, North,
South,
East,
West,
} }
#[derive(Debug, PartialEq)] #[derive(Debug, PartialEq)]
@ -47,26 +56,31 @@ enum Axis {
impl Direction { impl Direction {
fn reverse_direction(&self) -> bool { fn reverse_direction(&self) -> bool {
match self { match self {
Direction::North => false, Direction::North | Direction::West => false,
Direction::South | Direction::East => true,
} }
} }
fn axis(&self) -> Axis { fn axis(&self) -> Axis {
match self { match self {
Direction::North => Axis::Columns, Direction::North | Direction::South => Axis::Columns,
Direction::East | Direction::West => Axis::Rows,
} }
} }
} }
impl<'a> Platform { impl<'a> Platform {
fn width(&self) -> usize { 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> { 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>) { fn replace_col(&mut self, idx: usize, col: Vec<char>) {
for row_idx in 0..col.len() { 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) { fn roll(&mut self, dir: &Direction) {
@ -88,9 +102,30 @@ impl<'a> Platform {
self.roll_column(col, dir); self.roll_column(col, dir);
} }
} }
// This code could definitely be reused for rows
fn roll_column(&mut self, idx: usize, dir: &Direction) { fn roll_column(&mut self, idx: usize, dir: &Direction) {
let mut col = self.col(idx); 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() { for col_idx in 0..col.len() {
match col[col_idx] { match col[col_idx] {
'.' | '#' => continue, '.' | '#' => continue,
@ -110,19 +145,90 @@ impl<'a> Platform {
_ => panic!("invalid character"), _ => panic!("invalid character"),
} }
} }
}
self.replace_col(idx, col); self.replace_col(idx, col);
} }
fn score_columns(&self, dir: &Direction) -> u64 { 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| { .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 .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 { fn score_rows(&self, dir: &Direction) -> u64 {
unimplemented!() unimplemented!()
@ -131,7 +237,7 @@ impl<'a> Platform {
impl Display for Platform { impl Display for Platform {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 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 { for c in row {
f.write_char(*c)?; f.write_char(*c)?;
} }
@ -151,7 +257,17 @@ fn problem1<T: BufRead>(input: Lines<T>) -> u64 {
// PROBLEM 2 solution // PROBLEM 2 solution
fn problem2<T: BufRead>(input: Lines<T>) -> u64 { 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)] #[cfg(test)]
@ -179,6 +295,6 @@ O.#..O.#.#
#[test] #[test]
fn problem2_example() { fn problem2_example() {
let c = Cursor::new(EXAMPLE); let c = Cursor::new(EXAMPLE);
assert_eq!(problem2(c.lines()), 0); assert_eq!(problem2(c.lines()), 64);
} }
} }