day08.rs

use std::collections::HashSet;

fn visible_from_outside(grid: &Vec<Vec<usize>>) -> HashSet<(usize, usize)> {
    let mut visible = HashSet::new();
    // Any size map of (height, width)
    let max = (grid[0].len(), grid.len());
    // Scan horizontal
    for e in 1..max.0 - 1 {
        visible.extend(peek_south(&grid, (0, e), max.1));
        visible.extend(peek_north(&grid, (max.1 - 1, e)));
    }
    // Scan vertical
    for s in 1..max.1 - 1 {
        visible.extend(peek_east(&grid, (s, 0), max.0));
        visible.extend(peek_west(&grid, (s, max.0 - 1)));
    }
    // Include perimeter
    for i in 0..max.0 {
        visible.insert((i, 0));
        visible.insert((i, max.1 - 1));
    }
    for i in 0..max.1 {
        visible.insert((0, i));
        visible.insert((max.0 - 1, i));
    }

    visible
}

fn peek_north(grid: &Vec<Vec<usize>>, loc: (usize, usize)) -> HashSet<(usize, usize)> {
    let mut height = grid[loc.0][loc.1];
    let mut visible = HashSet::new();
    for row in (1..loc.0-1).rev() {
        if height < grid[row][loc.1] {
            height = grid[row][loc.1];
            visible.insert((row, loc.1));
        }
    }

    visible
}

fn peek_south(grid: &Vec<Vec<usize>>, loc: (usize, usize), map_h: usize) -> HashSet<(usize, usize)> {
    let mut height = grid[loc.0][loc.1];
    let mut visible = HashSet::new();
    for row in loc.0 + 1..map_h-1 {
        if height < grid[row][loc.1] {
            height = grid[row][loc.1];
            visible.insert((row, loc.1));
        }
    }

    visible
}

fn peek_east(grid: &Vec<Vec<usize>>, loc: (usize, usize), map_w: usize) -> HashSet<(usize, usize)> {
    let mut height = grid[loc.0][loc.1];
    let mut visible = HashSet::new();
    for col in loc.1 + 1..map_w-1 {
        if height < grid[loc.0][col] {
            height = grid[loc.0][col];
            visible.insert((loc.0, col));
        }
    }

    visible
}

fn peek_west(grid: &Vec<Vec<usize>>, loc: (usize, usize)) -> HashSet<(usize, usize)> {
    let mut height = grid[loc.0][loc.1];
    let mut visible = HashSet::new();
    for col in (1..loc.1-1).rev() {
        if height < grid[loc.0][col] {
            height = grid[loc.0][col];
            visible.insert((loc.0, col));
        }
    }

    visible
}

fn best_scene(grid: &Vec<Vec<usize>>) -> usize {
    let mut best_score = 0;
    for row in 0..grid.len() {
        for col in 0..grid[1].len() {
            let rating = get_rating(grid, row, col);
            if rating > best_score {
                best_score = rating;
            }
        }
    }

    best_score
}

fn get_rating(grid: &Vec<Vec<usize>>, row: usize, col: usize) -> usize {
    let dirs = [see_down, see_up, see_right, see_left];
    dirs.iter().map(|f| f(grid, row, col)).product()
}

fn see_up(grid: &Vec<Vec<usize>>, row: usize, col: usize) -> usize {
    let mut score = 0;
    let val = grid[row][col];
    for i in (0..row).rev() {
        score += 1;
        if val <= grid[i][col] {
            break;
        }
    }
    score
}

fn see_down(grid: &Vec<Vec<usize>>, row: usize, col: usize) -> usize {
    let map_height = grid.len();
    let mut score = 0;
    let val = grid[row][col];
    for i in row + 1..map_height {
        score += 1;
        if val <= grid[i][col] {
            break;
        }
    }
    score
}

fn see_right(grid: &Vec<Vec<usize>>, row: usize, col: usize) -> usize {
    let map_width = grid[0].len();
    let mut score = 0;
    let val = grid[row][col];
    for j in col + 1..map_width {
        score += 1;
        if val <= grid[row][j] {
            break;
        }
    }
    score
}

fn see_left(grid: &Vec<Vec<usize>>, row: usize, col: usize) -> usize {
    let mut score = 0;
    let val = grid[row][col];
    for j in (0..col).rev() {
        score += 1;
        if val <= grid[row][j] {
            break;
        }
    }
    score
}

#[aoc_generator(day8)]
pub fn input_generator(input: &str) -> Vec<Vec<usize>> {
    input
        .lines()
        .map(|line| {
            line.trim()
                .chars()
                .map(|c| c.to_digit(10).unwrap() as usize)
                .collect()
        })
        .collect()
}

#[aoc(day8, part1)]
pub fn solve_part1(input: &Vec<Vec<usize>>) -> usize {
    visible_from_outside(input).len()
}

#[aoc(day8, part2)]
pub fn solve_part2(input: &Vec<Vec<usize>>) -> usize {
    best_scene(input)
}

#[cfg(test)]
mod tests {
    use super::*;

    const TEST: &str = "30373
                        25512
                        65332
                        33549
                        35390";

    #[test]
    fn part1() {
        assert_eq!(solve_part1(&input_generator(TEST)), 21);
    }

    #[test]
    fn part2() {
        assert_eq!(solve_part2(&input_generator(TEST)), 8);
    }
}