85 lines
3.0 KiB
Rust
85 lines
3.0 KiB
Rust
use std::{collections::HashSet, fs::read_to_string};
|
|
|
|
fn main() {
|
|
let input = read_to_string("input.txt").unwrap();
|
|
let input = input
|
|
.lines()
|
|
.map(|line| {
|
|
line.chars()
|
|
.map(|c| String::from(c).parse::<i8>().unwrap())
|
|
.collect::<Vec<_>>()
|
|
})
|
|
.collect::<Vec<_>>();
|
|
let mut visible_trees = HashSet::new();
|
|
println!("size: {}x{}", input.len(), input[0].len());
|
|
if input.len() != input[0].len() {
|
|
panic!("field not square");
|
|
}
|
|
let length = input.len();
|
|
for i in 0..length {
|
|
let rev_i = length - i - 1;
|
|
let mut max_values = [-1; 4];
|
|
for j in 0..length {
|
|
let rev_j = length - j - 1;
|
|
if input[i][j] > max_values[0] {
|
|
max_values[0] = input[i][j];
|
|
visible_trees.insert((i, j));
|
|
}
|
|
if input[j][i] > max_values[1] {
|
|
max_values[1] = input[j][i];
|
|
visible_trees.insert((j, i));
|
|
}
|
|
if input[rev_i][rev_j] > max_values[2] {
|
|
max_values[2] = input[rev_i][rev_j];
|
|
visible_trees.insert((rev_i, rev_j));
|
|
}
|
|
if input[rev_j][rev_i] > max_values[3] {
|
|
max_values[3] = input[rev_j][rev_i];
|
|
visible_trees.insert((rev_j, rev_i));
|
|
}
|
|
}
|
|
}
|
|
|
|
let greatest_view = input
|
|
.iter()
|
|
.enumerate()
|
|
.map(|(x, line)| {
|
|
let input = &input;
|
|
line.iter().enumerate().map(move |(y, tree)| {
|
|
let mut view = [0; 4];
|
|
for radius in 1..length {
|
|
let left = x as isize - radius as isize;
|
|
let right = x as isize + radius as isize;
|
|
let up = y as isize - radius as isize;
|
|
let down = y as isize + radius as isize;
|
|
if view.iter().all(|v| *v != 0) {
|
|
break;
|
|
}
|
|
if x != 0 && view[0] == 0 && (left == 0 || input[left as usize][y] >= *tree) {
|
|
view[0] = radius;
|
|
}
|
|
if y != 0 && view[1] == 0 && (up == 0 || input[x][up as usize] >= *tree) {
|
|
view[1] = radius;
|
|
}
|
|
if x != length - 1
|
|
&& view[2] == 0
|
|
&& (right == length as isize - 1 || input[right as usize][y] >= *tree)
|
|
{
|
|
view[2] = radius;
|
|
}
|
|
if y != length - 1
|
|
&& view[3] == 0
|
|
&& (down == length as isize - 1 || input[x][down as usize] >= *tree)
|
|
{
|
|
view[3] = radius;
|
|
}
|
|
}
|
|
view.iter().fold(1, |p, v| p * v)
|
|
})
|
|
})
|
|
.flatten()
|
|
.max()
|
|
.unwrap();
|
|
println!("Greatest view is {}", greatest_view);
|
|
}
|