complete day 8

1 files changed, 120 insertions, 0 deletions

diff --git a/day08b/src/main.rs b/day08b/src/main.rs
new file mode 100644
index 0000000..c9d3a52
--- /dev/null
+++ b/day08b/src/main.rs
@@ -0,0 +1,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:?}");
+}