1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
|
/// --- Part Two ---
///
/// Content with the amount of tree cover available, the Elves just need to know the best spot to
/// build their tree house: they would like to be able to see a lot of trees.
///
/// To measure the viewing distance from a given tree, look up, down, left, and right from that
/// tree; stop if you reach an edge or at the first tree that is the same height or taller than the
/// tree under consideration. (If a tree is right on the edge, at least one of its viewing
/// distances will be zero.)
///
/// The Elves don't care about distant trees taller than those found by the rules above; the
/// proposed tree house has large eaves to keep it dry, so they wouldn't be able to see higher than
/// the tree house anyway.
///
/// In the example above, consider the middle 5 in the second row:
///
/// ```
/// 30373
/// 25512
/// 65332
/// 33549
/// 35390
/// ```
///
/// Looking up, its view is not blocked; it can see 1 tree (of height 3).
/// Looking left, its view is blocked immediately; it can see only 1 tree (of height 5, right
/// next to it).
/// Looking right, its view is not blocked; it can see 2 trees.
/// Looking down, its view is blocked eventually; it can see 2 trees (one of height 3, then the
/// tree of height 5 that blocks its view).
///
/// A tree's scenic score is found by multiplying together its viewing distance in each of the four
/// directions. For this tree, this is 4 (found by multiplying 1 * 1 * 2 * 2).
///
/// However, you can do even better: consider the tree of height 5 in the middle of the fourth row:
///
/// ```
/// 30373
/// 25512
/// 65332
/// 33549
/// 35390
/// ```
///
/// Looking up, its view is blocked at 2 trees (by another tree with a height of 5).
/// Looking left, its view is not blocked; it can see 2 trees.
/// Looking down, its view is also not blocked; it can see 1 tree.
/// Looking right, its view is blocked at 2 trees (by a massive tree of height 9).
///
/// This tree's scenic score is 8 (2 * 2 * 1 * 2); this is the ideal spot for the tree house.
///
/// Consider each tree on your map. What is the highest scenic score possible for any tree?
use clap::Parser;
use itertools::Itertools;
use std::fs::File;
use std::io::prelude::*;
use std::io::BufReader;
use std::path::PathBuf;
const FILEPATH: &'static str = "examples/input.txt";
#[derive(Parser, Debug)]
#[clap(author, version, about, long_about = None)]
struct Cli {
#[clap(short, long, default_value = FILEPATH)]
file: PathBuf,
}
fn main() {
let args = Cli::parse();
let file = File::open(&args.file).unwrap();
let reader = BufReader::new(file);
let grid = reader
.lines()
.map(|l| {
l.unwrap()
.chars()
.map(|c| c.to_digit(10).unwrap() as u8)
.collect_vec()
})
.collect_vec();
let xdim = grid.len();
let ydim = grid[0].len();
let res = (1..(xdim - 1))
.cartesian_product(1..(ydim - 1))
.map(|(idx, idy)| {
let tree = grid[idx][idy];
let top = (0..idx)
.rev()
.map(|t| tree as i32 - grid[t][idy] as i32)
.position(|diff| diff <= 0)
.unwrap_or(idx - 1)
+ 1;
let bottom = ((idx + 1)..xdim)
.map(|t| tree as i32 - grid[t][idy] as i32)
.position(|diff| diff <= 0)
.unwrap_or((xdim - idx) - 2)
+ 1;
let left = (0..idy)
.rev()
.map(|t| tree as i32 - grid[idx][t] as i32)
.position(|diff| diff <= 0)
.unwrap_or(idy - 1)
+ 1;
let right = ((idy + 1)..ydim)
.map(|t| tree as i32 - grid[idx][t] as i32)
.position(|diff| diff <= 0)
.unwrap_or((ydim - idy) - 2)
+ 1;
top * bottom * left * right
})
.max()
.unwrap();
println!("{res:?}");
}
|
