From a59be70c6356fce2796c8b18280602e4e0a6ee22 Mon Sep 17 00:00:00 2001 From: Ishan Jain Date: Sun, 10 Dec 2023 20:02:04 +0530 Subject: [PATCH] day10: Cleanup --- src/day10/1.rs | 439 ++++++++++++------------------------------- src/day10/2.rs | 340 ++++++++++++++++----------------- src/day10/sample.txt | 20 +- 3 files changed, 298 insertions(+), 501 deletions(-) diff --git a/src/day10/1.rs b/src/day10/1.rs index e698eb8..fee33c3 100644 --- a/src/day10/1.rs +++ b/src/day10/1.rs @@ -1,15 +1,95 @@ #![feature(test)] -use std::collections::VecDeque; - extern crate test; -const INPUTS: [&str; 2] = [include_str!("./sample.txt"), include_str!("./input.txt")]; +const INPUTS: [&str; 4] = [ + "..... +.S-7. +.|.|. +.L-J. +.....", + "..F7. +.FJ|. +SJ.L7 +|F--J +LJ...", + include_str!("./sample.txt"), + include_str!("./input.txt"), +]; + +#[derive(Debug)] +enum Direction { + Unknown, + North, + South, + East, + West, +} + +#[derive(Debug, Eq, PartialEq, Copy, Clone)] +enum Tile { + Vertical = 0x1, + Horizontal = 0x2, + L = 0x4, + J = 0x8, + Seven = 0x10, + F = 0x20, + Ground = 0x40, + Start = 0x80, +} + +impl From for Tile { + fn from(value: char) -> Self { + use Tile::*; + + match value { + '|' => Vertical, + '-' => Horizontal, + 'L' => L, + 'J' => J, + '7' => Seven, + 'F' => F, + '.' => Ground, + 'S' => Start, + + _ => unreachable!(), + } + } +} + +fn next_direction(a: char, dir: &Direction) -> (Direction, u8) { + use Direction::*; + use Tile::*; + match (a, dir) { + ('|', Unknown | North) => (North, Vertical as u8 | Seven as u8 | F as u8), + ('|', South) => (South, Vertical as u8 | L as u8 | J as u8), + + ('-', Unknown | West) => (West, Horizontal as u8 | L as u8 | F as u8), + ('-', East) => (East, Horizontal as u8 | J as u8 | Seven as u8), + + ('L', Unknown | West) => (North, Vertical as u8 | Seven as u8 | F as u8), + ('L', South) => (East, Horizontal as u8 | J as u8 | Seven as u8), + + ('J', Unknown | South) => (West, Horizontal as u8 | L as u8 | F as u8), + ('J', East) => (North, Vertical as u8 | F as u8 | Seven as u8), + + ('7', Unknown | East) => (South, Vertical as u8 | L as u8 | J as u8), + ('7', North) => (West, Horizontal as u8 | L as u8 | F as u8), + + ('F', Unknown | North) => (East, Horizontal as u8 | Seven as u8 | J as u8), + ('F', West) => (South, Vertical as u8 | L as u8 | J as u8), + + v => { + println!("{:?}", v); + unreachable!() + } + } +} fn process(data: &str) -> usize { let mut answer = std::usize::MAX; - let grid: Vec> = data + let mut grid: Vec> = data .lines() .filter(|x| !x.is_empty()) .map(|x| x.chars().collect()) @@ -28,336 +108,65 @@ fn process(data: &str) -> usize { } } } + 'outer: for c in ['-', '|', 'L', 'J', '7', 'F'] { + let mut start = true; - for mut c in ['F', 'L', '|', '-', 'J', '7'] { let mut sx = s_x; let mut sy = s_y; - let (mut px, mut py) = (s_x, s_y); let mut length = 0; + grid[sx][sy] = c; - while c != 'S' { - println!( - "({}, {}) => ({}, {}) c = {} {}", - px, py, sx, sy, c, grid[sx][sy] - ); + let mut direction = Direction::Unknown; - match c { - '|' => { - if sx > 0 && !(sx - 1 == px && sy == py) { - px = sx; - py = sy; - sx = sx - 1; - length += 1; - c = grid[sx][sy]; - } else if sx < m - 1 && !(sx + 1 == px && sy == py) { - px = sx; - py = sy; - sx = sx + 1; - length += 1; - c = grid[sx][sy]; - } - } - 'F' => { - if sy < n - 1 && !(sx == px && sy + 1 == py) { - px = sx; - py = sy; - sy = sy + 1; - length += 1; - c = grid[sx][sy]; - } else if sx < m - 1 && !(sx + 1 == px && px == py) { - px = sx; - py = sy; - sx = sx + 1; - length += 1; - c = grid[sx][sy]; - } - } + loop { + if !start && (sx == s_x && sy == s_y) { + break; + } + start = false; - '-' => { - if sy > 0 && !(sx == px && sy - 1 == py) { - px = sx; - py = sy; - sy = sy - 1; - length += 1; - c = grid[sx][sy]; - } else if sy < n - 1 && !(sx == px && sy + 1 == py) { - px = sx; - py = sy; - sy = sy + 1; - length += 1; - c = grid[sx][sy]; - } - } + if length >= answer { + continue 'outer; + } - '7' => { - if sy > 0 && !(sx == px && sy - 1 == py) { - px = sx; - py = sy; - sy = sy - 1; - length += 1; - c = grid[sx][sy]; - } else if sx < m - 1 && !(sx + 1 == px && sy == py) { - px = sx; - py = sy; - sx = sx + 1; - length += 1; - c = grid[sx][sy]; - } - } + // what we need to figure out the next step + // 1. The current character + // 2. Direction we are headed in + // 3. the potential next character. since it's possible we jump to an un jumpable + // character - 'J' => { - if sy > 0 && !(sx == px && sy - 1 == py) { - px = sx; - py = sy; - sy = sy - 1; - length += 1; - c = grid[sx][sy]; - } else if sx > 0 && !(sx - 1 == px && sy == py) { - px = sx; - py = sy; - sx = sx - 1; - length += 1; - c = grid[sx][sy]; - } - } + let (new_direction, valid_pipes) = next_direction(grid[sx][sy], &direction); - 'L' => { - if sx > 0 && !(sx - 1 == px && sy == py) { - px = sx; - py = sy; - sx = sx - 1; - length += 1; - c = grid[sx][sy]; - } else if sy < n - 1 && !(sx == px && sy + 1 == py) { - px = sx; - py = sy; - sy = sy + 1; - length += 1; - c = grid[sx][sy]; - } - } - '.' => break, + let (x, y) = match new_direction { + Direction::Unknown => unreachable!(), + Direction::North => (-1, 0), + Direction::South => (1, 0), + Direction::East => (0, 1), + Direction::West => (0, -1), + }; - _ => unreachable!(), + let p = sx as i32 + x; + let q = sy as i32 + y; + if p < 0 || q < 0 || p >= m as i32 || q >= n as i32 { + continue 'outer; + } + + let next_pipe = Tile::from(grid[p as usize][q as usize]); + if valid_pipes & next_pipe as u8 > 0 { + sx = p as usize; + sy = q as usize; + direction = new_direction; + length += 1; + } else { + continue 'outer; } } answer = std::cmp::min(answer, length / 2); } - return answer; - - // let mut stack = vec![]; - // // let mut q = VecDeque::new(); - // stack.push((sx, sy, 'F', sx, sy, 0)); - // stack.push((sx, sy, 'L', sx, sy, 0)); - - let mut min_dist = vec![vec![std::usize::MAX; n]; m]; - - // while let Some((sx, sy, c, px, py, distance)) = stack.pop() { - // min_dist[sx][sy] = std::cmp::min(min_dist[sx][sy], distance); - // match c { - // '|' => { - // if sx > 0 && !(sx - 1 == px && sy == py) { - // let c = grid[sx - 1][sy]; - // stack.push((sx - 1, sy, c, sx, sy, distance + 1)); - // } - // if sx < m - 1 && !(sx + 1 == px && sy == py) { - // let c = grid[sx + 1][sy]; - // stack.push((sx + 1, sy, c, sx, sy, distance + 1)); - // } - // } - // - // '-' => { - // if sy > 0 && !(sx == px && sy - 1 == py) { - // let c = grid[sx][sy - 1]; - // stack.push((sx, sy - 1, c, sx, sy, distance + 1)); - // } - // if sy < n - 1 && !(sx == px && sy + 1 == py) { - // let c = grid[sx][sy + 1]; - // stack.push((sx, sy + 1, c, sx, sy, distance + 1)); - // } - // } - // - // 'L' => { - // if sx > 0 && !(sx - 1 == px && sy == py) { - // let c = grid[sx - 1][sy]; - // stack.push((sx - 1, sy, c, sx, sy, distance + 1)); - // } - // if sy < n - 1 && !(sx == px && sy + 1 == py) { - // let c = grid[sx][sy + 1]; - // stack.push((sx, sy + 1, c, sx, sy, distance + 1)); - // } - // } - // - // 'J' => { - // if sy > 0 && !(sx == px && sy - 1 == py) { - // let c = grid[sx][sy - 1]; - // stack.push((sx, sy - 1, c, sx, sy, distance + 1)); - // } - // if sx > 0 && !(sx - 1 == px && sy == py) { - // let c = grid[sx - 1][sy]; - // stack.push((sx - 1, sy, c, sx, sy, distance + 1)); - // } - // } - // - // '7' => { - // if sy > 0 && !(sx == px && sy - 1 == py) { - // let c = grid[sx][sy - 1]; - // stack.push((sx, sy - 1, c, sx, sy, distance + 1)); - // } - // if sx < m - 1 && !(sx + 1 == px && sy == py) { - // let c = grid[sx + 1][sy]; - // stack.push((sx + 1, sy, c, sx, sy, distance + 1)); - // } - // } - // - // 'F' => { - // if sy < n - 1 && !(sx == px && sy + 1 == py) { - // let c = grid[sx][sy + 1]; - // stack.push((sx, sy + 1, c, sx, sy, distance + 1)); - // } - // if sx < m - 1 && !(sx + 1 == px && px == py) { - // let c = grid[sx + 1][sy]; - // stack.push((sx + 1, sy, c, sx, sy, distance + 1)); - // } - // } - // - // '.' => (), - // - // 'S' => (), - // - // v => { - // unreachable!() - // } - // } - // } - // - println!(); - - for line in min_dist { - println!("{:?}", line); - - for c in line { - if c == std::usize::MAX { - continue; - } - - answer = std::cmp::max(answer, c); - } - } - println!(); - - // for &(sx, sy, c) in [(sx, sy, 'F')].iter() { - // let mut visited = vec![vec![false; n]; m]; - // - // // dfs(&grid, &mut visited, &mut path, sx, sy, c, 0); - // } - answer } -fn dfs( - grid: &Vec>, - visited: &mut Vec>, - path: &mut Vec, - sx: usize, - sy: usize, - c: char, - distance: usize, -) { - if visited[sx][sy] { - // return; - } else { - visited[sx][sy] = true; - } - - if c == 'S' { - return; - } - - path.push(c); - - println!("({},{}) = {} {}", sx, sy, c, distance); - - let m = grid.len(); - let n = grid[0].len(); - - match c { - '|' => { - if sx > 0 { - let c = grid[sx - 1][sy]; - dfs(grid, visited, path, sx - 1, sy, c, distance + 1); - } - if sx < m - 1 { - let c = grid[sx + 1][sy]; - dfs(grid, visited, path, sx + 1, sy, c, distance + 1); - } - } - - '-' => { - if sy > 0 { - let c = grid[sx][sy - 1]; - dfs(grid, visited, path, sx, sy - 1, c, distance + 1); - } - if sy < n - 1 { - let c = grid[sx][sy + 1]; - dfs(grid, visited, path, sx, sy + 1, c, distance + 1); - } - } - - 'L' => { - if sx > 0 { - let c = grid[sx - 1][sy]; - dfs(grid, visited, path, sx - 1, sy, c, distance + 1); - } - if sy < n - 1 { - let c = grid[sx][sy + 1]; - dfs(grid, visited, path, sx, sy + 1, c, distance + 1); - } - } - - 'J' => { - if sy > 0 { - let c = grid[sx][sy - 1]; - dfs(grid, visited, path, sx, sy - 1, c, distance + 1); - } - if sx > 0 { - let c = grid[sx - 1][sy]; - dfs(grid, visited, path, sx - 1, sy, c, distance + 1); - } - } - - '7' => { - if sy > 0 { - let c = grid[sx][sy - 1]; - dfs(grid, visited, path, sx, sy - 1, c, distance + 1); - } - if sx < m - 1 { - let c = grid[sx + 1][sy]; - dfs(grid, visited, path, sx + 1, sy, c, distance + 1); - } - } - - 'F' => { - if sy < n - 1 { - let c = grid[sx][sy + 1]; - dfs(grid, visited, path, sx, sy + 1, c, distance + 1); - } - if sx < m - 1 { - let c = grid[sx + 1][sy]; - dfs(grid, visited, path, sx + 1, sy, c, distance + 1); - } - } - - '.' => (), - - _ => unreachable!(), - } - - path.pop(); -} - fn main() { for input in INPUTS.iter() { println!("total = {}", process(input)); @@ -367,7 +176,7 @@ fn main() { #[bench] fn part1(b: &mut test::Bencher) { b.iter(|| { - let v = process(INPUTS[1]); + let v = process(INPUTS[INPUTS.len() - 1]); test::black_box(v); }); } diff --git a/src/day10/2.rs b/src/day10/2.rs index 96024aa..9363e6c 100644 --- a/src/day10/2.rs +++ b/src/day10/2.rs @@ -2,7 +2,116 @@ extern crate test; -const INPUTS: [&str; 2] = [include_str!("./sample.txt"), include_str!("./input.txt")]; +const INPUTS: [&str; 5] = [ + "........... +.S-------7. +.|F-----7|. +.||.....||. +.||.....||. +.|L-7.F-J|. +.|..|.|..|. +.L--J.L--J. +...........", + ".......... +.S------7. +.|F----7|. +.||OOOO||. +.||OOOO||. +.|L-7F-J|. +.|II||II|. +.L--JL--J. +..........", + "FF7FSF7F7F7F7F7F---7 +L|LJ||||||||||||F--J +FL-7LJLJ||||||LJL-77 +F--JF--7||LJLJ7F7FJ- +L---JF-JLJ.||-FJLJJ7 +|F|F-JF---7F7-L7L|7| +|FFJF7L7F-JF7|JL---7 +7-L-JL7||F7|L7F-7F7| +L.L7LFJ|||||FJL7||LJ +L7JLJL-JLJLJL--JLJ.L", + ".F----7F7F7F7F-7.... +.|F--7||||||||FJ.... +.||.FJ||||||||L7.... +FJL7L7LJLJ||LJ.L-7.. +L--J.L7...LJS7F-7L7. +....F-J..F7FJ|L7L7L7 +....L7.F7||L7|.L7L7| +.....|FJLJ|FJ|F7|.LJ +....FJL-7.||.||||... +....L---J.LJ.LJLJ...", + include_str!("./input.txt"), +]; + +#[derive(Debug)] +enum Direction { + Unknown, + North, + South, + East, + West, +} + +#[derive(Debug, Eq, PartialEq, Copy, Clone)] +enum Tile { + Vertical = 0x1, + Horizontal = 0x2, + L = 0x4, + J = 0x8, + Seven = 0x10, + F = 0x20, + Ground = 0x40, + Start = 0x80, + + // Reusing a bitmap because these will never be togther in a single map + X = 0x1 | 0x2, +} + +impl From for Tile { + fn from(value: char) -> Self { + use Tile::*; + + match value { + '|' => Vertical, + '-' => Horizontal, + 'L' => L, + 'J' => J, + '7' => Seven, + 'F' => F, + '.' => Ground, + 'S' => Start, + + _ => unreachable!(), + } + } +} + +fn next_direction(a: char, dir: &Direction) -> (Direction, u8) { + use Direction::*; + use Tile::*; + match (a, dir) { + ('|', Unknown | North) => (North, Vertical as u8 | Seven as u8 | F as u8), + ('|', South) => (South, Vertical as u8 | L as u8 | J as u8), + + ('-', Unknown | West) => (West, Horizontal as u8 | L as u8 | F as u8), + ('-', East) => (East, Horizontal as u8 | J as u8 | Seven as u8), + + ('L', Unknown | West) => (North, Vertical as u8 | Seven as u8 | F as u8), + ('L', South) => (East, Horizontal as u8 | J as u8 | Seven as u8), + + ('J', Unknown | South) => (West, Horizontal as u8 | L as u8 | F as u8), + ('J', East) => (North, Vertical as u8 | F as u8 | Seven as u8), + + ('7', Unknown | East) => (South, Vertical as u8 | L as u8 | J as u8), + ('7', North) => (West, Horizontal as u8 | L as u8 | F as u8), + + ('F', Unknown | North) => (East, Horizontal as u8 | Seven as u8 | J as u8), + ('F', West) => (South, Vertical as u8 | L as u8 | J as u8), + + _ => unreachable!(), + } +} fn process(data: &str) -> usize { let mut answer = 0; @@ -26,186 +135,60 @@ fn process(data: &str) -> usize { } } - let mut map = vec![vec!['.'; n]; m]; + let mut map = vec![vec![Tile::Ground; n]; m]; - 'outer: for mut c in ['|', '-', 'L', 'J', '7', 'F'] { + 'outer: for c in ['-', '|', 'L', 'J', '7', 'F'] { + let mut start = true; + grid[s_x][s_y] = c; let mut sx = s_x; let mut sy = s_y; - let (mut px, mut py) = (s_x, s_y); - let mut start = true; - grid[sx][sy] = c; + let mut direction = Direction::Unknown; + let mut local_map = map.clone(); - let mut tmp_map = map.clone(); - - while start || !(sx == s_x && sy == s_y) { + loop { + if !start && (sx == s_x && sy == s_y) { + break; + } start = false; - tmp_map[sx][sy] = c; + local_map[sx][sy] = Tile::from(grid[sx][sy]); + // what we need to figure out the next step + // 1. The current character + // 2. Direction we are headed in + // 3. the potential next character. since it's possible we jump to an un jumpable + // character - match c { - '|' => { - if sx > 0 - && !(sx - 1 == px && sy == py) - && ['7', 'F', '|', 'S'].contains(&grid[sx - 1][sy]) - { - px = sx; - py = sy; - sx -= 1; - c = grid[sx][sy]; - } else if sx < m - 1 - && !(sx + 1 == px && sy == py) - && ['L', 'J', '|', 'S'].contains(&grid[sx + 1][sy]) - { - px = sx; - py = sy; - sx += 1; - c = grid[sx][sy]; - } else { - continue 'outer; - } - } - 'F' => { - if sy < n - 1 - && !(sx == px && sy + 1 == py) - && ['-', 'J', '7', 'S'].contains(&grid[sx][sy + 1]) - { - px = sx; - py = sy; - sy += 1; - c = grid[sx][sy]; - } else if sx < m - 1 - && !(sx + 1 == px && px == py) - && ['L', 'J', '|', 'S'].contains(&grid[sx + 1][sy]) - { - px = sx; - py = sy; - sx += 1; - c = grid[sx][sy]; - } else { - continue 'outer; - } - } + let (new_direction, valid_pipes) = next_direction(grid[sx][sy], &direction); - '-' => { - if sy > 0 - && !(sx == px && sy - 1 == py) - && ['L', 'F', '-', 'S'].contains(&grid[sx][sy - 1]) - { - px = sx; - py = sy; - sy -= 1; - c = grid[sx][sy]; - } else if sy < n - 1 - && !(sx == px && sy + 1 == py) - && ['J', '7', '-', 'S'].contains(&grid[sx][sy + 1]) - { - px = sx; - py = sy; - sy += 1; - c = grid[sx][sy]; - } else { - continue 'outer; - } - } + let (x, y) = match new_direction { + Direction::Unknown => unreachable!(), + Direction::North => (-1, 0), + Direction::South => (1, 0), + Direction::East => (0, 1), + Direction::West => (0, -1), + }; - '7' => { - if sy > 0 - && !(sx == px && sy - 1 == py) - && ['L', 'F', '-', 'S'].contains(&grid[sx][sy - 1]) - { - px = sx; - py = sy; - sy -= 1; - c = grid[sx][sy]; - } else if sx < m - 1 - && !(sx + 1 == px && sy == py) - && ['L', 'J', '|', 'S'].contains(&grid[sx + 1][sy]) - { - px = sx; - py = sy; - sx += 1; - c = grid[sx][sy]; - } else { - continue 'outer; - } - } + let p = sx as i32 + x; + let q = sy as i32 + y; + if p < 0 || q < 0 || p >= m as i32 || q >= n as i32 { + continue 'outer; + } - 'J' => { - if sy > 0 - && !(sx == px && sy - 1 == py) - && ['L', 'F', '-', 'S'].contains(&grid[sx][sy - 1]) - { - px = sx; - py = sy; - sy -= 1; - c = grid[sx][sy]; - } else if sx > 0 - && !(sx - 1 == px && sy == py) - && ['7', 'F', '|', 'S'].contains(&grid[sx - 1][sy]) - { - px = sx; - py = sy; - sx -= 1; - c = grid[sx][sy]; - } else { - continue 'outer; - } - } - - 'L' => { - if sx > 0 - && !(sx - 1 == px && sy == py) - && ['7', 'F', '|', 'S'].contains(&grid[sx - 1][sy]) - { - px = sx; - py = sy; - sx -= 1; - c = grid[sx][sy]; - } else if sy < n - 1 - && !(sx == px && sy + 1 == py) - && ['J', '7', '-', 'S'].contains(&grid[sx][sy + 1]) - { - px = sx; - py = sy; - sy += 1; - c = grid[sx][sy]; - } else { - continue 'outer; - } - } - '.' => continue 'outer, - - _ => unreachable!(), + let next_pipe = Tile::from(grid[p as usize][q as usize]); + if valid_pipes & next_pipe as u8 > 0 { + sx = p as usize; + sy = q as usize; + direction = new_direction; + } else { + continue 'outer; } } - match ( - sx as i32 - px as i32, - sy as i32 - py as i32, - grid[px][py], - grid[sx][sy], - ) { - (-1, 0, 'J', 'F') => (), - (-1, 0, '|', '|') => { - if sx == 0 || sx == m - 1 { - continue; - } - } - (-1, 0, '|', '7') => (), - (-1, 0, '|', 'F') => (), - (0, -1, 'J', 'L') => (), - - _ => unreachable!(), - }; - - if sx == s_x && sy == s_y { - map = tmp_map; - break; - } + map = local_map; } - let mut nmap = vec![vec!['.'; n * 2]; m * 2]; + let mut nmap = vec![vec![Tile::Ground; n * 2]; m * 2]; for (i, line) in map.iter().enumerate() { for (j, c) in line.iter().enumerate() { @@ -213,29 +196,34 @@ fn process(data: &str) -> usize { } } + use Tile::*; for line in nmap.iter_mut() { for j in 0..2 * n - 2 { - if ['F', 'L', '-'].contains(&line[j]) && ['J', '7', '-'].contains(&line[j + 2]) { - line[j + 1] = '-'; + if (line[j] as u8 & (F as u8 | L as u8 | Horizontal as u8)) > 0 + && (line[j + 2] as u8 & (J as u8 | Seven as u8 | Horizontal as u8)) > 0 + { + line[j + 1] = Horizontal; } } } for j in 0..n * 2 { for i in 0..m * 2 - 2 { - if ['F', '7', '|'].contains(&nmap[i][j]) && ['L', 'J', '|'].contains(&nmap[i + 2][j]) { - nmap[i + 1][j] = '|'; + if (nmap[i][j] as u8 & (F as u8 | Seven as u8 | Vertical as u8)) > 0 + && (nmap[i + 2][j] as u8 & (L as u8 | J as u8 | Vertical as u8)) > 0 + { + nmap[i + 1][j] = Vertical; } } } for j in 0..2 * n { - if nmap[0][j] == '.' { - flood_fill(&mut nmap, 0, j, 'X'); + if nmap[0][j] == Ground { + flood_fill(&mut nmap, 0, j, X); } } - let mut out = vec![vec!['.'; n]; m]; + let mut out = vec![vec![Tile::Ground; n]; m]; for (i, line) in nmap.iter().enumerate() { if i % 2 != 0 { @@ -253,7 +241,7 @@ fn process(data: &str) -> usize { for line in out.into_iter() { for c in line.into_iter() { - if c == '.' { + if c == Tile::Ground { answer += 1; } } @@ -262,7 +250,7 @@ fn process(data: &str) -> usize { answer } -fn flood_fill(map: &mut Vec>, i: usize, j: usize, fill_with: char) { +fn flood_fill(map: &mut Vec>, i: usize, j: usize, fill_with: Tile) { let m = map.len(); let n = map[0].len(); const DIRS: [[i32; 2]; 4] = [[0, 1], [0, -1], [-1, 0], [1, 0]]; @@ -271,7 +259,7 @@ fn flood_fill(map: &mut Vec>, i: usize, j: usize, fill_with: char) { stack.push((i, j)); while let Some((sx, sy)) = stack.pop() { - if map[sx][sy] != '.' { + if map[sx][sy] != Tile::Ground { continue; } @@ -302,7 +290,7 @@ fn main() { #[bench] fn part1(b: &mut test::Bencher) { b.iter(|| { - let v = process(INPUTS[1]); + let v = process(INPUTS[INPUTS.len() - 1]); test::black_box(v); }); } diff --git a/src/day10/sample.txt b/src/day10/sample.txt index adaae96..fbc0300 100644 --- a/src/day10/sample.txt +++ b/src/day10/sample.txt @@ -1,10 +1,10 @@ -.F----7F7F7F7F-7.... -.|F--7||||||||FJ.... -.||.FJ||||||||L7.... -FJL7L7LJLJ||LJ.L-7.. -L--J.L7...LJS7F-7L7. -....F-J..F7FJ|L7L7L7 -....L7.F7||L7|.L7L7| -.....|FJLJ|FJ|F7|.LJ -....FJL-7.||.||||... -....L---J.LJ.LJLJ... +FF7FSF7F7F7F7F7F---7 +L|LJ||||||||||||F--J +FL-7LJLJ||||||LJL-77 +F--JF--7||LJLJ7F7FJ- +L---JF-JLJ.||-FJLJJ7 +|F|F-JF---7F7-L7L|7| +|FFJF7L7F-JF7|JL---7 +7-L-JL7||F7|L7F-7F7| +L.L7LFJ|||||FJL7||LJ +L7JLJL-JLJLJL--JLJ.L \ No newline at end of file