island_perimeter.rs

pub type Grid = Vec<Vec<u8>>;

pub fn grid_perimeter(grid: Grid) -> usize {
    grid.iter()
        .enumerate()
        .map(|(i, row)| {
            row.iter()
                .enumerate()
                .filter_map(|(j, cell)| if *cell == 1 { Some(j) } else { None })
                .map(|j| {
                    get_neighbours(&grid, row, i, j)
                        .iter()
                        .filter(|cell| **cell == 0)
                        .count()
                })
                .sum::<usize>()
        })
        .sum::<usize>()
}

fn get_neighbours(grid: &Grid, row: &Vec<u8>, i: usize, j: usize) -> [u8; 4] {
    let top = *grid
        .get(i.wrapping_sub(1))
        .and_then(|top_row| top_row.get(j))
        .unwrap_or(&0);
    let bottom = *grid
        .get(i + 1)
        .and_then(|top_row| top_row.get(j))
        .unwrap_or(&0);
    let left = *row.get(j.wrapping_sub(1)).unwrap_or(&0);
    let right = *row.get(j + 1).unwrap_or(&0);

    [top, bottom, left, right]
}

#[cfg(test)]
mod tests {
    use crate::grid_perimeter;

    #[test]
    fn test_1() {
        let grid = vec![
            vec![0, 0, 0, 0, 0, 0],
            vec![0, 1, 0, 0, 0, 0],
            vec![0, 1, 0, 0, 0, 0],
            vec![0, 1, 1, 1, 0, 0],
            vec![0, 0, 0, 0, 0, 0],
        ];

        assert_eq!(grid_perimeter(grid), 12);
    }

    #[test]
    fn test_2() {
        let grid = vec![
            vec![1, 1, 1, 1, 1],
            vec![1, 1, 1, 1, 1],
            vec![1, 1, 1, 1, 1],
        ];

        assert_eq!(grid_perimeter(grid), 16);
    }

    #[test]
    fn test_3() {
        let grid = vec![
            vec![0, 0, 0, 0, 0, 0],
            vec![0, 1, 1, 0, 0, 0],
            vec![1, 1, 1, 0, 0, 0],
            vec![0, 1, 1, 1, 0, 0],
            vec![0, 0, 0, 1, 1, 1],
        ];

        assert_eq!(grid_perimeter(grid), 20);
    }

    #[test]
    fn test_4() {
        let grid = vec![
            vec![0, 1, 0, 0, 0, 1],
            vec![1, 1, 0, 0, 0, 1],
            vec![1, 1, 0, 1, 1, 1],
            vec![0, 1, 1, 1, 0, 0],
            vec![0, 0, 1, 1, 0, 0],
        ];

        assert_eq!(grid_perimeter(grid), 28);
    }
}