1 files changed, 103 insertions, 0 deletions
diff --git a/2018/src/bin/day_6.rs b/2018/src/bin/day_6.rs
new file mode 100644
index 0000000..16c8782
--- /dev/null
+++ b/2018/src/bin/day_6.rs
@@ -0,0 +1,103 @@
+extern crate advent_of_code_2018;
+use advent_of_code_2018::*;
+
+use std::error::Error;
+use std::path::PathBuf;
+
+use std::collections::{HashSet, HashMap};
+
+// cargo watch -cs "cargo run --release --bin day_6"
+
+fn main() -> Result<(), Box<Error>> {
+    let input = read_file(&PathBuf::from("inputs/6.txt"))?;
+    let coordinates = input.iter().map(|line| {
+        let mut split = line.split(|c: char| !c.is_numeric());
+        let x: i32 = split.next().unwrap().parse().unwrap();
+        let _ = split.next();
+        let y: i32 = split.next().unwrap().parse().unwrap();
+        (x, y)
+    }).collect::<Vec<_>>();
+    debug!(coordinates);
+
+    let min_x = coordinates.iter().map(|(x, _)| x).min().unwrap().clone();
+    let max_x = coordinates.iter().map(|(x, _)| x).max().unwrap().clone();
+    let min_y = coordinates.iter().map(|(_, y)| y).min().unwrap().clone();
+    let max_y = coordinates.iter().map(|(_, y)| y).max().unwrap().clone();
+    
+    debug!(min_x);
+    debug!(max_x);
+    debug!(min_y);
+    debug!(max_y);
+
+    let mut infinite = HashSet::new();
+    for x in min_x..max_x+1 {
+        for y in &[0, max_y] {
+            if let Some(coord) = find_closest(&coordinates, x, *y) {
+                infinite.insert(coord);
+            }
+        }
+    }
+    for y in min_y..max_y+1 {
+        for x in &[0, max_x] {
+            if let Some(coord) = find_closest(&coordinates, *x, y) {
+                infinite.insert(coord);
+            }
+        }
+    }
+
+    debug!(infinite);
+    
+
+    let mut areas = HashMap::new();
+    for x in min_x..max_x+1 {
+        for y in min_y..max_y+1 {
+            if let Some(coord) = find_closest(&coordinates, x, y) {
+                *areas.entry(coord).or_insert(0) += 1;
+            }
+        }
+    }
+
+    debug!(areas);
+
+    let biggest_non_infinite = areas.iter()
+        .filter(|(k,_)| !infinite.contains(&k))
+        .max_by_key(|(_,v)| *v);
+    debug!(biggest_non_infinite);
+    
+
+
+    let safe_distance = 10000;
+    let mut safe_size = 0;
+    for x in min_x..max_x+1 {
+        for y in min_y..max_y+1 {
+            let distance_sum: i32 = coordinates.iter()
+                .map(|(x1, y1)| manhattan_distance(*x1, *y1, x, y))
+                .sum();
+            if distance_sum < safe_distance {
+                safe_size += 1;
+            }
+        }
+    }
+    debug!(safe_size);
+    
+    Ok(())
+}
+
+fn find_closest(coordinates: &Vec<(i32, i32)>, x: i32, y: i32) -> Option<usize> {
+    let mut distances = coordinates.iter()
+        .map(|(x1, y1)| manhattan_distance(*x1, *y1, x, y))
+        .enumerate()
+        .collect::<Vec<_>>();
+    distances.sort_by_key(|(_, d)| *d);
+
+    if distances[0] == distances[1] {
+        None
+    }
+    else {
+        distances.first().map(|(i, _)| *i)
+    }
+}
+
+fn manhattan_distance(x1: i32, y1: i32, x2: i32, y2: i32) -> i32 {
+    (x2-x1).abs() + (y2-y1).abs()
+}