[2024] Day 9 initial solution

Author: connorslade

README.md

@@ -13,6 +13,7 @@ Thank you to [Eric Wastl](http://was.tl) for running this incredible yearly even
 - [Day 06: Guard Gallivant](aoc_2024/src/day_06.rs)
 - [Day 07: Bridge Repair](aoc_2024/src/day_07.rs)
 - [Day 08: Resonant Collinearity](aoc_2024/src/day_08.rs)
+- [Day 09: Disk Fragmenter](aoc_2024/src/day_09.rs)
 <!-- MARKER -->
 
 ## [2023](https://adventofcode.com/2023) [![aoc_2023](https://github.com/connorslade/advent-of-code/actions/workflows/aoc_2023.yml/badge.svg)](https://github.com/connorslade/advent-of-code/actions/workflows/aoc_2023.yml)

aoc_2024/src/day_09.rs

@@ -0,0 +1,149 @@
+use common::{solution, Answer};
+use itertools::Itertools;
+
+solution!("Disk Fragmenter", 9);
+
+fn part_a(input: &str) -> Answer {
+    let mut problem = Problem::parse(input);
+    problem.sort_blocks();
+    problem.score_blocks().into()
+}
+
+fn part_b(input: &str) -> Answer {
+    let mut problem = Problem::parse(input);
+    problem.sort_files();
+    problem.score_files().into()
+}
+
+#[derive(Debug)]
+struct Problem {
+    blocks: Vec<Option<u32>>,
+    files: Vec<File>,
+}
+
+#[derive(Debug)]
+struct File {
+    pos: u32,
+    size: u8,
+    id: u32,
+}
+
+impl Problem {
+    fn parse(input: &str) -> Self {
+        let mut blocks = Vec::new();
+        let mut files = Vec::new();
+
+        let mut id = 0;
+        let mut pos = 0;
+
+        for (idx, chr) in input.trim().char_indices() {
+            let num = chr.to_digit(10).unwrap() as u8;
+
+            if idx % 2 == 1 {
+                for _ in 0..num {
+                    blocks.push(None);
+                }
+            } else {
+                files.push(File { pos, size: num, id });
+                for _ in 0..num {
+                    blocks.push(Some(id));
+                }
+                id += 1;
+            }
+
+            pos += num as u32;
+        }
+
+        Self { blocks, files }
+    }
+
+    fn sort_blocks(&mut self) {
+        loop {
+            let empty = self.blocks.iter().position(|x| x.is_none()).unwrap();
+            let last = self.blocks.iter().rposition(|x| x.is_some()).unwrap();
+
+            if last > empty {
+                self.blocks.swap(empty, last);
+            } else {
+                break;
+            }
+        }
+    }
+
+    fn sort_files(&mut self) {
+        let max_id = self.files.last().unwrap().id;
+        for id in (0..=max_id).rev() {
+            let file_idx = self.files.iter().position(|x| x.id == id).unwrap();
+            let file = &self.files[file_idx];
+
+            let mut new_pos = None;
+            for (a, b) in self.files.iter().tuple_windows() {
+                let free = (b.pos) - (a.pos + a.size as u32);
+                let pos = a.pos + a.size as u32;
+
+                if pos > file.pos {
+                    break;
+                }
+
+                if free >= file.size as u32 {
+                    new_pos = Some(pos);
+                    break;
+                }
+            }
+
+            if let Some(new_pos) = new_pos {
+                self.files[file_idx].pos = new_pos;
+            }
+
+            self.files.sort_by_key(|x| x.pos);
+        }
+    }
+
+    fn score_blocks(&self) -> u64 {
+        let mut sum = 0;
+
+        for (idx, id) in self.blocks.iter().enumerate() {
+            sum += idx as u64 * id.unwrap_or_default() as u64;
+        }
+
+        sum
+    }
+
+    fn score_files(&self) -> u64 {
+        let mut sum = 0;
+        let mut last = 0;
+        let mut idx = 0;
+        for x in &self.files {
+            for _ in last..x.pos {
+                idx += 1;
+            }
+
+            for _ in 0..x.size {
+                sum += idx * x.id as u64;
+                idx += 1;
+            }
+
+            last = x.pos + x.size as u32;
+        }
+        sum
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use indoc::indoc;
+
+    const CASE: &str = indoc! {"
+        2333133121414131402
+    "};
+
+    #[test]
+    fn part_a() {
+        assert_eq!(super::part_a(CASE), 1928.into());
+    }
+
+    #[test]
+    fn part_b() {
+        assert_eq!(super::part_b(CASE), 2858.into());
+    }
+}

aoc_2024/src/lib.rs

@@ -8,6 +8,7 @@ mod day_05;
 mod day_06;
 mod day_07;
 mod day_08;
+mod day_09;
 // [import_marker]
 
 pub const SOLUTIONS: &[Solution] = &[
@@ -19,5 +20,6 @@ pub const SOLUTIONS: &[Solution] = &[
     day_06::SOLUTION,
     day_07::SOLUTION,
     day_08::SOLUTION,
+    day_09::SOLUTION,
     // [list_marker]
 ];

aoc_lib/src/matrix.rs

@@ -43,7 +43,7 @@ impl<T> Matrix<T> {
         pos.x() < self.size.x() && pos.y() < self.size.y()
     }
 
-    pub fn iter(&self) -> impl Iterator<Item = (Vec2<usize>, &T)> + use<'_, T> {
+    pub fn iter(&self) -> impl Iterator<Item = (Vec2<usize>, &T)> {
         (0..self.data.len()).map(|x| {
             let pos = vector!(x % self.size.x(), x / self.size.x());
             let data = self.get(pos).unwrap();