factor out some grid parsing

5 files changed, 62 insertions, 71 deletions

diff --git a/src/2020/3/mod.rs b/src/2020/3/mod.rs
index 4676a45..b702199 100644
--- a/src/2020/3/mod.rs
+++ b/src/2020/3/mod.rs
@@ -5,30 +5,8 @@ struct Map {
 }
 
 impl Map {
-    fn parse(s: impl Iterator<Item = u8>) -> anyhow::Result<Self> {
-        let mut grid = vec![];
-        let mut current_row = vec![];
-        for c in s {
-            match c {
-                b'#' => {
-                    current_row.push(true);
-                }
-                b'.' => {
-                    current_row.push(false);
-                }
-                b'\n' => {
-                    grid.push(current_row);
-                    current_row = vec![];
-                }
-                _ => {
-                    return Err(anyhow::anyhow!("invalid map char: '{}'", c));
-                }
-            }
-        }
-        if !current_row.is_empty() {
-            grid.push(current_row);
-        }
-        Ok(Self { grid })
+    fn new(grid: Vec<Vec<bool>>) -> Self {
+        Self { grid }
     }
 
     fn rows(&self) -> usize {
@@ -65,12 +43,12 @@ impl Map {
 }
 
 pub fn part1() -> anyhow::Result<i64> {
-    let map = read_map()?;
+    let map = Map::new(data_bool_map!(b'#', b'.'));
     map.trees_for_slope(3, 1)
 }
 
 pub fn part2() -> anyhow::Result<i64> {
-    let map = read_map()?;
+    let map = Map::new(data_bool_map!(b'#', b'.'));
     Ok(map.trees_for_slope(1, 1)?
         * map.trees_for_slope(3, 1)?
         * map.trees_for_slope(5, 1)?
@@ -78,10 +56,6 @@ pub fn part2() -> anyhow::Result<i64> {
         * map.trees_for_slope(1, 2)?)
 }
 
-fn read_map() -> anyhow::Result<Map> {
-    Map::parse(data_bytes!()?)
-}
-
 #[test]
 fn test() {
     assert_eq!(part1().unwrap(), 292);
diff --git a/src/2021/11/mod.rs b/src/2021/11/mod.rs
index 8c4874a..cec5759 100644
--- a/src/2021/11/mod.rs
+++ b/src/2021/11/mod.rs
@@ -1,4 +1,4 @@
-fn iterate(map: &mut Vec<Vec<(i64, bool)>>) -> i64 {
+fn iterate(map: &mut Vec<Vec<(u8, bool)>>) -> i64 {
     let mut flashes = 0;
     for line in map.iter_mut() {
         for (cell, _) in line.iter_mut() {
@@ -47,14 +47,10 @@ fn iterate(map: &mut Vec<Vec<(i64, bool)>>) -> i64 {
 }
 
 pub fn part1() -> anyhow::Result<i64> {
-    let mut map = data_lines!()?
-        .map(|line| {
-            line.bytes()
-                .map(|b| ((b - b'0') as i64, false))
-                .collect::<Vec<_>>()
-        })
-        .collect::<Vec<_>>();
-
+    let mut map: Vec<Vec<_>> = data_digit_grid!()
+        .iter()
+        .map(|line| line.iter().map(|i| (*i, false)).collect())
+        .collect();
     let mut flashes = 0;
     for _ in 0..100 {
         flashes += iterate(&mut map);
@@ -63,13 +59,10 @@ pub fn part1() -> anyhow::Result<i64> {
 }
 
 pub fn part2() -> anyhow::Result<i64> {
-    let mut map = data_lines!()?
-        .map(|line| {
-            line.bytes()
-                .map(|b| ((b - b'0') as i64, false))
-                .collect::<Vec<_>>()
-        })
-        .collect::<Vec<_>>();
+    let mut map: Vec<Vec<_>> = data_digit_grid!()
+        .iter()
+        .map(|line| line.iter().map(|i| (*i, false)).collect())
+        .collect();
 
     let mut step = 1;
     loop {
diff --git a/src/2021/15/mod.rs b/src/2021/15/mod.rs
index e1bbf33..10659ab 100644
--- a/src/2021/15/mod.rs
+++ b/src/2021/15/mod.rs
@@ -42,16 +42,11 @@ fn dijkstra(map: &[Vec<u8>]) -> i64 {
 }
 
 pub fn part1() -> anyhow::Result<i64> {
-    let map: Vec<Vec<_>> = data_lines!()?
-        .map(|line| line.bytes().map(|b| b - b'0').collect())
-        .collect();
-    Ok(dijkstra(&map))
+    Ok(dijkstra(&data_digit_grid!()))
 }
 
 pub fn part2() -> anyhow::Result<i64> {
-    let map: Vec<Vec<_>> = data_lines!()?
-        .map(|line| line.bytes().map(|b| b - b'0').collect())
-        .collect();
+    let map = data_digit_grid!();
     let mut large_map = vec![vec![0; map.len() * 5]; map[0].len() * 5];
     for li in 0..5 {
         for lj in 0..5 {
diff --git a/src/2021/9/mod.rs b/src/2021/9/mod.rs
index 1046c6c..1d9c0f2 100644
--- a/src/2021/9/mod.rs
+++ b/src/2021/9/mod.rs
@@ -1,13 +1,5 @@
 pub fn part1() -> anyhow::Result<i64> {
-    let mut map = vec![];
-    for line in data_lines!()? {
-        let mut row = vec![];
-        for c in line.bytes() {
-            row.push(c - b'0');
-        }
-        map.push(row);
-    }
-
+    let map = data_digit_grid!();
     let mut risk = 0;
     for i in 0..map.len() {
         for j in 0..map[0].len() {
@@ -36,15 +28,7 @@ pub fn part1() -> anyhow::Result<i64> {
 }
 
 pub fn part2() -> anyhow::Result<i64> {
-    let mut map = vec![];
-    for line in data_lines!()? {
-        let mut row = vec![];
-        for c in line.bytes() {
-            row.push(c - b'0');
-        }
-        map.push(row);
-    }
-
+    let map = data_digit_grid!();
     let mut low = vec![];
     for i in 0..map.len() {
         for j in 0..map[0].len() {
diff --git a/src/util.rs b/src/util.rs
index fce6389..03c3c6b 100644
--- a/src/util.rs
+++ b/src/util.rs
@@ -1,3 +1,6 @@
+#![allow(unused_macros)]
+#![allow(dead_code)]
+
 use std::io::{BufRead as _, Read as _};
 
 macro_rules! data {
@@ -36,6 +39,18 @@ macro_rules! data_str {
     }};
 }
 
+macro_rules! data_bool_map {
+    ($t:expr, $f:expr) => {{
+        crate::util::bool_map(data_lines!().unwrap(), $t, $f)
+    }};
+}
+
+macro_rules! data_digit_grid {
+    () => {{
+        crate::util::digit_map(data_lines!().unwrap())
+    }};
+}
+
 pub fn src_file_to_data_file(file: &str) -> String {
     let parts: Vec<_> = file.split('/').collect();
     format!(
@@ -79,6 +94,36 @@ pub fn string(fh: std::fs::File) -> String {
     std::string::String::from_utf8(bytes).unwrap()
 }
 
+pub fn bool_map(
+    lines: impl Iterator<Item = String>,
+    t: u8,
+    f: u8,
+) -> Vec<Vec<bool>> {
+    lines
+        .map(|s| {
+            s.as_bytes()
+                .iter()
+                .copied()
+                .map(|b| {
+                    if b == f {
+                        false
+                    } else if b == t {
+                        true
+                    } else {
+                        panic!("unrecognized character {}", char::from(b))
+                    }
+                })
+                .collect()
+        })
+        .collect()
+}
+
+pub fn digit_map(lines: impl Iterator<Item = String>) -> Vec<Vec<u8>> {
+    lines
+        .map(|s| s.as_bytes().iter().copied().map(|b| b - b'0').collect())
+        .collect()
+}
+
 pub struct Adjacent {
     x: usize,
     y: usize,