88 lines
2.6 KiB
Rust
88 lines
2.6 KiB
Rust
#![feature(test)]
|
|
extern crate test;
|
|
use itertools::Itertools;
|
|
use std::iter::repeat;
|
|
|
|
use aoc2022::{boilerplate, common::*};
|
|
|
|
const DAY: usize = 8;
|
|
type Parsed = Vec<Vec<u8>>;
|
|
|
|
fn parse_input(raw: &str) -> Parsed {
|
|
raw.lines().map(|l| l.as_bytes().to_vec()).collect()
|
|
}
|
|
|
|
fn is_visible_1d<'a>(iter: impl IntoIterator<Item = &'a u8>, rev: bool) -> Vec<bool> {
|
|
let mut v: Vec<_> = iter
|
|
.into_iter()
|
|
.scan(0, |max, tree| {
|
|
let visible = tree > max;
|
|
*max = *tree.max(max);
|
|
Some(visible)
|
|
})
|
|
.collect();
|
|
if rev {
|
|
v.reverse();
|
|
}
|
|
v
|
|
}
|
|
|
|
fn transpose<T: Copy>(v: &Vec<Vec<T>>) -> Vec<Vec<T>> {
|
|
let len = v.len();
|
|
let mut iters: Vec<_> = v.iter().map(|n| n.iter()).collect();
|
|
(0..len).map(|_| iters.iter_mut().map(|i| i.next().unwrap()).copied().collect::<Vec<T>>()).collect()
|
|
}
|
|
|
|
fn horizontally_visible(v: &[Vec<u8>]) -> Vec<Vec<bool>> {
|
|
v.iter().map(|l| is_visible_1d(l, false).into_iter().zip(is_visible_1d(l.iter().rev(), true)).map(|(a, b)| a || b).collect()).collect()
|
|
}
|
|
|
|
fn part1(parsed: &Parsed) -> usize {
|
|
let horizontal = horizontally_visible(parsed);
|
|
let vertical = horizontally_visible(&transpose(parsed));
|
|
(0..parsed.len()).flat_map(|i| repeat(i).zip(0..parsed.len())).filter(|&(i, j)| horizontal[i][j] || vertical[j][i]).count()
|
|
}
|
|
|
|
fn part2(parsed: &Parsed) -> usize {
|
|
let size = parsed.len(); // input is always square
|
|
(1..size - 1)
|
|
.flat_map(|i| repeat(i).zip(1..size - 1))
|
|
.map(|(i, j)| {
|
|
let tree = parsed[i][j];
|
|
let a = visible_trees(((i + 1)..size).map(|i| parsed[i][j]), tree);
|
|
let b = visible_trees((0..i).rev().map(|i| parsed[i][j]), tree);
|
|
let c = visible_trees(((j + 1)..size).map(|j| parsed[i][j]), tree);
|
|
let d = visible_trees((0..j).rev().map(|j| parsed[i][j]), tree);
|
|
a * b * c * d
|
|
})
|
|
.max()
|
|
.unwrap()
|
|
}
|
|
|
|
#[inline] // this inline actually saves ~40% runtime
|
|
fn visible_trees(heights: impl Iterator<Item = u8>, tree: u8) -> usize {
|
|
let mut heights = heights.peekable();
|
|
heights.peeking_take_while(|&t| t < tree).count() + heights.peek().map(|_| 1).unwrap_or(0)
|
|
}
|
|
|
|
#[cfg(test)]
|
|
const TEST_OUTPUT: &[bool] = &[true, true, false, true, false];
|
|
|
|
boilerplate! {
|
|
TEST_INPUT == "30373
|
|
25512
|
|
65332
|
|
33549
|
|
35390",
|
|
tests: {
|
|
part1: { TEST_INPUT => 21 },
|
|
part2: { TEST_INPUT => 8 },
|
|
},
|
|
unittests: {
|
|
is_visible_1d: { [1, 3, 2, 4, 2].iter(), false => TEST_OUTPUT, },
|
|
},
|
|
bench1 == 1543,
|
|
bench2 == 595080,
|
|
bench_parse: Vec::len => 99,
|
|
}
|