Day 8

day8/src/main.rs

@@ -1,3 +1,84 @@
+use std::{collections::HashSet, fs::read_to_string};
+
 fn main() {
-    println!("Hello, world!");
+    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);
 }