cargo fmt

src/main.rs

@@ -1,20 +1,20 @@
-use std::collections::HashMap;
-use std::thread;
-use std::ops::RangeInclusive;
-use std::panic;
-use std::str;
 use std::cmp;
-use std::ops::Sub;
+use std::collections::HashMap;
-use std::ops::{Deref};
-use std::fs;
 use std::convert::TryFrom;
+use std::fs;
+use std::ops::Deref;
+use std::ops::RangeInclusive;
+use std::ops::Sub;
+use std::panic;
 use std::process;
+use std::str;
 use std::sync::Arc;
+use std::thread;
 
 #[derive(Default, Debug, PartialEq)]
 struct Location {
     x: isize,
-    y: isize
+    y: isize,
 }
 impl<'a> Sub for &'a Location {
     type Output = isize;
@@ -30,22 +30,22 @@ struct Sensor {
 }
 #[derive(Default, Debug, PartialEq)]
 struct Beacon {
-    loc: Location
+    loc: Location,
 }
 
-
 struct ComparableRange(RangeInclusive<isize>);
 
 impl ComparableRange {
     pub fn intersects(&self, other: &ComparableRange) -> bool {
-        self.contains(other.start()) ||
+        self.contains(other.start()) || other.contains(self.start())
-        other.contains(self.start())
     }
 
     pub fn intersection(&self, other: &ComparableRange) -> ComparableRange {
         match self.intersects(other) {
             false => panic!("Ranges do not intersect"),
-            true => ComparableRange(cmp::min(*self.start(), *other.start())..=cmp::max(*self.end(),*other.end()))
+            true => ComparableRange(
+                cmp::min(*self.start(), *other.start())..=cmp::max(*self.end(), *other.end()),
+            ),
         }
     }
 }
@@ -71,7 +71,10 @@ fn run() {
     process_part_2(contents.lines());
 }
 
-fn process_part_2<'a, T>(lines: T) where T: IntoIterator<Item = &'a str> {
+fn process_part_2<'a, T>(lines: T)
+where
+    T: IntoIterator<Item = &'a str>,
+{
     let (sensors, worker_bundles) = prep_work(lines);
 
     let mut handles = Vec::new();
@@ -81,13 +84,18 @@ fn process_part_2<'a, T>(lines: T) where T: IntoIterator<Item = &'a str> {
         let worker_bundles = Arc::clone(&bundle_storage);
         let sensors = Arc::clone(&sensor_storage);
         let bounds = 0..=PART_2_CONST;
-        let handle = thread::spawn(move || {do_part2_work(worker_bundles, worker, &bounds, sensors)} );
+        let handle = thread::spawn(move || do_part2_work(worker_bundles, worker, &bounds, sensors));
         handles.push(handle);
     }
-    handles.into_iter().for_each(|handle|{ handle.join();});
+    handles.into_iter().for_each(|handle| {
+        handle.join();
+    });
 }
 
-fn prep_work<'a, T>(lines: T) -> (Vec<Sensor>, HashMap<isize, Vec<usize>>) where T: IntoIterator<Item = &'a str> {
+fn prep_work<'a, T>(lines: T) -> (Vec<Sensor>, HashMap<isize, Vec<usize>>)
+where
+    T: IntoIterator<Item = &'a str>,
+{
     let (sensors, _) = parse(lines);
     let mut worker_bundles = HashMap::new();
     for worker in 0..99 {
@@ -97,7 +105,7 @@ fn prep_work<'a, T>(lines: T) -> (Vec<Sensor>, HashMap<isize, Vec<usize>>) where
             work_item.push(chunk_s);
         }
         worker_bundles.insert(worker, work_item);
-    };
+    }
     // remainder worker
     let worker = 99;
     let mut work_item = Vec::new();
@@ -110,23 +118,41 @@ fn prep_work<'a, T>(lines: T) -> (Vec<Sensor>, HashMap<isize, Vec<usize>>) where
     (sensors, worker_bundles)
 }
 
-fn do_part2_work(worker_bundles: Arc<HashMap<isize, Vec<usize>>>, worker: isize, bounds: &RangeInclusive<isize>, sensors: Arc<Vec<Sensor>>) {
+fn do_part2_work(
-    worker_bundles.get(&worker).and_then(
+    worker_bundles: Arc<HashMap<isize, Vec<usize>>>,
-        |x| {
+    worker: isize,
+    bounds: &RangeInclusive<isize>,
+    sensors: Arc<Vec<Sensor>>,
+) {
+    worker_bundles.get(&worker).and_then(|x| {
         for (work_idx, work_item) in x.into_iter().enumerate() {
             for idx in 0..*work_item {
-                let dist = isize::try_from(idx).unwrap() + worker*isize::try_from(*work_item).unwrap();
+                let dist =
+                    isize::try_from(idx).unwrap() + worker * isize::try_from(*work_item).unwrap();
                 let sensor = &sensors[work_idx];
                 let visibility = isize::try_from(sensor.visibility).unwrap();
                 let x_left = sensor.loc.x - dist;
                 let x_right = sensor.loc.x + dist;
                 let y_lower = sensor.loc.y + (visibility - dist) + 1;
                 let y_upper = sensor.loc.y - (visibility - dist) - 1;
-                [(x_left, y_upper), (x_right, y_upper), (x_left, y_lower), (x_right, y_lower)].into_iter().for_each(|coord| {
+                [
-                    if !(bounds).contains(&coord.0) || !(bounds).contains(&coord.1) { return }
+                    (x_left, y_upper),
-                    if (sensors).iter().all(|tgt_sensor| {
+                    (x_right, y_upper),
-                        &tgt_sensor.loc - &Location{x:coord.0, y:coord.1} > isize::try_from(tgt_sensor.visibility).unwrap()
+                    (x_left, y_lower),
-
+                    (x_right, y_lower),
+                ]
+                .into_iter()
+                .for_each(|coord| {
+                    if !(bounds).contains(&coord.0) || !(bounds).contains(&coord.1) {
+                        return;
+                    }
+                    if sensors.iter().all(|tgt_sensor| {
+                        &tgt_sensor.loc
+                            - &Location {
+                                x: coord.0,
+                                y: coord.1,
+                            }
+                            > isize::try_from(tgt_sensor.visibility).unwrap()
                     }) {
                         println!("{:?}", coord.0 * 4000000 + coord.1);
                         process::exit(0);
@@ -138,30 +164,51 @@ fn do_part2_work(worker_bundles: Arc<HashMap<isize, Vec<usize>>>, worker: isize,
     });
 }
 
-fn process_part_1<'a, T>(lines: T) where T: IntoIterator<Item = &'a str> {
+fn process_part_1<'a, T>(lines: T)
+where
+    T: IntoIterator<Item = &'a str>,
+{
     let (sensors, beacons) = parse(lines);
     let target_row = PART_1_CONST;
     let mut impossible_ranges: Vec<ComparableRange> = Vec::new();
     for sensor in (&sensors).into_iter() {
         let visibility = isize::try_from(sensor.visibility).unwrap();
-        let dist_to_target = &sensor.loc - &(Location {x:sensor.loc.x, y:target_row});
+        let dist_to_target = &sensor.loc
-        if dist_to_target > visibility { continue }
+            - &(Location {
+                x: sensor.loc.x,
+                y: target_row,
+            });
+        if dist_to_target > visibility {
+            continue;
+        }
 
         let impossible_width = visibility - dist_to_target;
         let impossible_range = sensor.loc.x - impossible_width..=sensor.loc.x + impossible_width;
         impossible_ranges.push(ComparableRange(impossible_range));
-    };
+    }
     impossible_ranges.sort_by(|a, b| a.start().cmp(b.start()));
 
     merge(&mut impossible_ranges);
 
-    let beacons_in_row = beacons.into_iter().filter(|b| {
+    let beacons_in_row = beacons
+        .into_iter()
+        .filter(|b| {
             if b.loc.y != target_row {
-            return false
+                return false;
             }
-        (&impossible_ranges).into_iter().any(|r| r.contains(&b.loc.x))
+            (&impossible_ranges)
-    }).count();
+                .into_iter()
-    println!("{}", impossible_ranges.into_iter().map(|r| r.end()-r.start()+1).sum::<isize>()-isize::try_from(beacons_in_row).unwrap());
+                .any(|r| r.contains(&b.loc.x))
+        })
+        .count();
+    println!(
+        "{}",
+        impossible_ranges
+            .into_iter()
+            .map(|r| r.end() - r.start() + 1)
+            .sum::<isize>()
+            - isize::try_from(beacons_in_row).unwrap()
+    );
 }
 
 fn merge(impossible_ranges: &mut Vec<ComparableRange>) {
@@ -180,27 +227,32 @@ fn merge(impossible_ranges: &mut Vec<ComparableRange>) {
 }
 
 fn parse<'a, T>(lines: T) -> (Vec<Sensor>, Vec<Beacon>)
-where T: IntoIterator<Item = &'a str> {
+where
+    T: IntoIterator<Item = &'a str>,
+{
     let mut sensors = Vec::new();
     let mut beacons = Vec::new();
     let extract_ints = |s: &str| {
-        s
+        s.split(&['=', ',', ':'][..])
-            .split(&['=',',',':'][..])
             .filter_map(|s| s.parse::<isize>().ok())
             .collect::<Vec<isize>>()
     };
     let loc_sets = lines.into_iter().map(extract_ints);
     loc_sets.for_each(|loc_set| {
-        let sensor_loc = Location {x:loc_set[0], y:loc_set[1]};
+        let sensor_loc = Location {
-        let beacon_loc = Location {x:loc_set[2], y:loc_set[3]};
+            x: loc_set[0],
+            y: loc_set[1],
+        };
+        let beacon_loc = Location {
+            x: loc_set[2],
+            y: loc_set[3],
+        };
         let visibility = usize::try_from(&sensor_loc - &beacon_loc).unwrap();
         sensors.push(Sensor {
             loc: sensor_loc,
-            visibility: visibility
+            visibility: visibility,
         });
-        let beacon = Beacon{
+        let beacon = Beacon { loc: beacon_loc };
-            loc: beacon_loc
-        };
         if !beacons.contains(&beacon) {
             beacons.push(beacon);
         }