day 14 make faster

src/day09.rs

@@ -1,4 +1,4 @@
-use std::fs::read_to_string;
+use std::{collections::BTreeMap, fs::read_to_string};
 
 pub fn day_main() {
     let input = read_to_string("input/day09.txt").unwrap();
@@ -53,48 +53,41 @@ fn part1(input: &str) -> RiddleResult {
 }
 
 fn part2(input: &str) -> RiddleResult {
-    let mut disk = Vec::with_capacity(input.len() * 10);
+    let mut free: BTreeMap<usize, usize> = BTreeMap::new();
     // (start_index, len, file_id)
-    let mut files: Vec<(usize, u32, usize)> = Vec::with_capacity(input.len() / 2 + 1);
+    let mut files: Vec<(usize, usize, usize)> = Vec::with_capacity(input.len() / 2 + 1);
+    let mut head = 0;
     for (i, l) in input.chars().enumerate() {
-        let l = l.to_digit(10).unwrap();
+        let l = l.to_digit(10).unwrap() as usize;
-        let content = if i % 2 == 0 {
-            // file
-            Some(i / 2) // id based on order of apperance and every second one is a file
-        } else {
-            None
-        };
         if i % 2 == 0 {
-            files.push((disk.len(), l, i / 2));
+            files.push((head, l, i / 2));
-        }
+        } else {
-        for _ in 0..l {
+            free.insert(head, l);
-            disk.push(content);
         }
+        head += l as usize;
     }
-    while let Some((start_index, length, file_id)) = files.pop() {
+    for file in files.iter_mut().rev() {
-        let mut seeker = 0;
+        let (start_index, length, _file_id) = *file;
-        let mut found = None;
+        let found = free
-        while disk[seeker] != Some(file_id) {
+            .iter()
-            if disk[seeker..seeker + length as usize]
+            .take_while(|f| *f.0 < start_index)
-                .iter()
+            .find(|f| *f.1 >= length);
-                .all(|v| v.is_none())
+
-            {
+        if let Some((&free_start, &free_length)) = found.clone() {
-                found = Some(seeker);
+            free.remove(&free_start);
-                break;
+            free.insert(start_index, length);
-            }
+            file.0 = free_start;
-            seeker += 1;
+            if length < free_length {
-        }
+                free.insert(free_start + length, free_length - length);
-        if let Some(empty_start) = found {
-            for i in 0..length as usize {
-                disk[empty_start + i] = Some(file_id);
-                disk[start_index + i] = None;
             }
         }
     }
 
-    disk.into_iter()
+    files
-        .enumerate()
+        .iter()
-        .map(|(i, v)| if let Some(value) = v { i * value } else { 0 })
+        .map(|(start_index, l, file_id)| {
+            *file_id * (*start_index..start_index + l).sum::<RiddleResult>()
+        })
         .sum()
 }
 

src/day13.rs

@@ -0,0 +1,99 @@
+use std::fs::read_to_string;
+
+use itertools::Itertools;
+use regex::Regex;
+
+pub fn day_main() {
+    let input = read_to_string("input/day13.txt").unwrap();
+    let input = input.trim();
+    println!(" part1: {}", part1(input));
+    println!(" part2: {}", part2(input));
+}
+
+type RiddleResult = i64;
+
+fn part1(input: &str) -> RiddleResult {
+    // Button A: X+30, Y+84
+    // Button B: X+74, Y+60
+    // Prize: X=2358, Y=2628
+    let r = Regex::new(
+        r"Button A: X\+(\d+), Y\+(\d+)
+Button B: X\+(\d+), Y\+(\d+)
+Prize: X=(\d+), Y=(\d+)",
+    )
+    .unwrap();
+    r.captures_iter(input)
+        .map(|block| {
+            let (ax, ay, bx, by, px, py) = block
+                .iter()
+                .skip(1)
+                .map(|it| it.unwrap().as_str().parse::<i64>().unwrap())
+                .collect_tuple()
+                .unwrap();
+            solve((ax, ay, bx, by, px, py)).unwrap_or(0)
+        })
+        .sum()
+}
+
+fn part2(input: &str) -> RiddleResult {
+    let r = Regex::new(
+        r"Button A: X\+(\d+), Y\+(\d+)
+Button B: X\+(\d+), Y\+(\d+)
+Prize: X=(\d+), Y=(\d+)",
+    )
+    .unwrap();
+    r.captures_iter(input)
+        .map(|block| {
+            let (ax, ay, bx, by, px, py) = block
+                .iter()
+                .skip(1)
+                .map(|it| it.unwrap().as_str().parse::<i64>().unwrap())
+                .collect_tuple()
+                .unwrap();
+            let solution = solve((ax, ay, bx, by, px + 10000000000000, py + 10000000000000));
+            solution.unwrap_or(0)
+        })
+        .sum()
+}
+
+fn solve((ax, ay, bx, by, px, py): (i64, i64, i64, i64, i64, i64)) -> Option<RiddleResult> {
+    let b = (ay * px - ax * py) / (ay * bx - ax * by);
+    let a = (px - b * bx) / ax;
+    if a >= 0 && b >= 0 && a * ax + b * bx == px && a * ay + b * by == py {
+        Some(3 * a + b)
+    } else {
+        None
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::{part1, part2};
+
+    const TEST_INPUT: &str = r"Button A: X+94, Y+34
+Button B: X+22, Y+67
+Prize: X=8400, Y=5400
+
+Button A: X+26, Y+66
+Button B: X+67, Y+21
+Prize: X=12748, Y=12176
+
+Button A: X+17, Y+86
+Button B: X+84, Y+37
+Prize: X=7870, Y=6450
+
+Button A: X+69, Y+23
+Button B: X+27, Y+71
+Prize: X=18641, Y=10279
+";
+
+    #[test]
+    fn test1() {
+        assert_eq!(part1(TEST_INPUT), 480);
+    }
+
+    #[test]
+    fn test2() {
+        assert_eq!(part2(TEST_INPUT), 875318608908);
+    }
+}

src/day14.rs

@@ -0,0 +1,163 @@
+use std::{
+    collections::HashSet,
+    fs::read_to_string,
+    io::{self, BufRead},
+    ops::Sub,
+};
+
+use itertools::Itertools;
+
+use crate::utils::grid::Grid;
+
+pub fn day_main() {
+    let input = read_to_string("input/day14.txt").unwrap();
+    let input = input.trim();
+    println!(" part1: {}", part1(input));
+    println!(" part2: {}", part2(input));
+}
+
+type RiddleResult = usize;
+
+fn part1(input: &str) -> RiddleResult {
+    solve_part1(input, 100, 101, 103)
+}
+
+fn solve_part1(input: &str, rounds: i64, width: i64, height: i64) -> RiddleResult {
+    let mut robots = parse(input);
+    for _ in 0..rounds {
+        robots.iter_mut().for_each(|((px, py), (vx, vy))| {
+            *px = (*px + width + *vx) % width;
+            *py = (*py + height + *vy) % height;
+        });
+    }
+    let upper_left = robots
+        .iter()
+        .filter(|&&((px, py), _)| px < width / 2 && py < height / 2)
+        .count();
+    let lower_left = robots
+        .iter()
+        .filter(|&&((px, py), _)| px < width / 2 && py > height / 2)
+        .count();
+    let upper_right = robots
+        .iter()
+        .filter(|&&((px, py), _)| px > width / 2 && py < height / 2)
+        .count();
+    let lower_right = robots
+        .iter()
+        .filter(|&&((px, py), _)| px > width / 2 && py > height / 2)
+        .count();
+
+    upper_left * lower_left * upper_right * lower_right
+}
+
+fn parse(input: &str) -> Vec<((i64, i64), (i64, i64))> {
+    input
+        .lines()
+        .map(|line| {
+            line.strip_prefix("p=")
+                .unwrap()
+                .split(" v=")
+                .map(|s| {
+                    s.split(",")
+                        .map(|d| d.parse::<i64>().unwrap())
+                        .collect_tuple::<(i64, i64)>()
+                        .unwrap()
+                })
+                .collect_tuple()
+                .unwrap()
+        })
+        .collect_vec()
+}
+
+#[allow(unused)]
+fn part2(input: &str) -> RiddleResult {
+    let width = 101;
+    let height = 103;
+    let mut robots = parse(input);
+    let mut seen = HashSet::new();
+    for second in 0.. {
+        if seen.contains(&robots) {
+            panic!("Loop after {second} rounds, but no christmas tree!");
+        }
+        let mut grid: Grid<u8> = Grid::from_default(101, 103);
+        seen.insert(robots.clone());
+        robots.iter_mut().for_each(|((px, py), (vx, vy))| {
+            *px = (*px + width + *vx) % width;
+            *py = (*py + height + *vy) % height;
+            grid[(*px, *py)] += 1;
+            if let Some(v) = grid.get_mut((*px + 1, *py)) {
+                *v += 1
+            }
+            if let Some(v) = grid.get_mut((*px - 1, *py)) {
+                *v += 1
+            }
+            if let Some(v) = grid.get_mut((*px, *py + 1)) {
+                *v += 1
+            }
+            if let Some(v) = grid.get_mut((*px, *py - 1)) {
+                *v += 1
+            }
+        });
+
+        if robots.iter().filter(|(s, _)| grid[*s] > 1).count() > robots.len() * 70 / 100 {
+            printr(&robots, width, height);
+            println!("after {} seconds. Press enter to continue or type 'merry christmas' if you can spot a tree!", second + 1); //+1 because we look at it after they have changed
+            let stdin = io::stdin();
+            let line = stdin.lock().lines().next().unwrap().unwrap();
+            if line.as_str().eq_ignore_ascii_case("merry christmas") {
+                return second + 1;
+            }
+        }
+    }
+    unreachable!()
+}
+
+type Robot = ((i64, i64), (i64, i64));
+
+fn printr(robots: &[Robot], width: i64, height: i64) {
+    for y in 0..height {
+        for x in 0..width {
+            let c = robots
+                .iter()
+                .filter(|&&((px, py), _)| px == x && py == y)
+                .count();
+            if c == 0 {
+                print!(".");
+            } else {
+                print!("{c}");
+            }
+        }
+        println!();
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::day14::solve_part1;
+
+    use super::part2;
+
+    const TEST_INPUT: &str = r"p=0,4 v=3,-3
+p=6,3 v=-1,-3
+p=10,3 v=-1,2
+p=2,0 v=2,-1
+p=0,0 v=1,3
+p=3,0 v=-2,-2
+p=7,6 v=-1,-3
+p=3,0 v=-1,-2
+p=9,3 v=2,3
+p=7,3 v=-1,2
+p=2,4 v=2,-3
+p=9,5 v=-3,-3
+";
+
+    #[test]
+    fn test1() {
+        assert_eq!(solve_part1(TEST_INPUT, 100, 11, 7), 12);
+    }
+
+    #[test]
+    fn test2() {
+        assert_eq!(part2(TEST_INPUT), 0);
+    }
+}

src/lib.rs

@@ -10,5 +10,7 @@ pub mod day09;
 pub mod day10;
 pub mod day11;
 pub mod day12;
+pub mod day13;
+pub mod day14;
 // PLACEHOLDER
 pub mod utils;

src/main.rs

@@ -17,6 +17,8 @@ fn main() {
         (10, day10::day_main),
         (11, day11::day_main),
         (12, day12::day_main),
+        (13, day13::day_main),
+        (14, day14::day_main),
         // PLACEHOLDER
     ]);
     let day: Option<u8> = args().nth(1).and_then(|a| a.parse().ok());

src/utils/grid.rs

@@ -4,6 +4,7 @@ use std::{
 };
 
 use itertools::Itertools;
+use regex::bytes::Replacer;
 
 /// A grid structure, indexed by (x, y) tuples. The top-left coordinate is (0, 0).
 #[derive(Eq, PartialEq, Debug, Clone)]
@@ -99,6 +100,21 @@ impl<T> Grid<T> {
     }
 }
 
+impl<T> Grid<T>
+where
+    T: Default,
+{
+    pub fn from_default(width: i64, height: i64) -> Grid<T> {
+        let mut content: Vec<T> = Vec::with_capacity((width * height) as usize);
+        content.resize_with((width * height) as usize, Default::default);
+        Grid {
+            content_width: width,
+            content_height: height,
+            content,
+        }
+    }
+}
+
 impl Grid<char> {
     pub fn parse(input: &str) -> Grid<char> {
         let content_width = input.lines().next().unwrap().len();