Tweak parsing and add comments

src/year2021/day19.rs

@@ -14,9 +14,10 @@
 //! factor of 24.
 //!
 //! The set of Euclidean distance squared between all beacons is a good choice, as it's invariant
-//! under rotation, quick to calculate and a good discriminant. To check for an overlap of 12
-//! beacons, we look for an overlap of a least 12 * 11 / 2 = 66 distances. (12 pairs is 12 * 11
-//! different distances but divided by 2 since the distance from a -> b is the same as b -> a).
+//! under rotation and translation, quick to calculate and a good discriminant. To check for an
+//! overlap of 12 beacons, we look for an overlap of a least 12 * 11 / 2 = 66 distances.
+//! (12 beacons gives 12 * 11 = 132 pairs of distances but divided by 2 since the distance from
+//! a -> b is the same as b -> a).
 //!
 //! An overlap indicates a potential match, but we need to confirm by checking the beacons against
 //! each other in two steps. First confirming orientation by matching the deltas between
@@ -31,8 +32,7 @@ use std::ops::{Add, Sub};
 struct Point3D(i32, i32, i32);
 
 impl Point3D {
-    fn parse(line: &&str) -> Point3D {
-        let [x, y, z] = line.iter_signed().chunk::<3>().next().unwrap();
+    fn parse([x, y, z]: [i32; 3]) -> Point3D {
         Point3D(x, y, z)
     }
 
@@ -112,9 +112,14 @@ struct Scanner {
 impl Scanner {
     /// Calculate the signature as the set of Euclidean distance squared between every possible
     /// pair of beacons.
-    fn parse(lines: &[&str]) -> Scanner {
-        let beacons: Vec<_> = lines.iter().skip(1).map(Point3D::parse).collect();
+    fn parse(block: &str) -> Scanner {
+        // Each beacon header results in 5 mangled numbers at the start that should be skipped.
+        let beacons: Vec<_> =
+            block.iter_signed().skip(5).chunk::<3>().map(Point3D::parse).collect();
 
+        // Include indices of the points so that we can match translation and rotation for
+        // points that have the same signature. Use indices so that we don't need to recalculate
+        // signature when rotating and translation a beacon from unknown to known.
         let mut signature = FastMap::with_capacity(1_000);
         for i in 0..(beacons.len() - 1) {
             for j in (i + 1)..beacons.len() {
@@ -164,9 +169,7 @@ impl Located {
 /// Convert the raw input into a vec of unknown scanners, then do all the heavy lifting of figuring
 /// out the relative orientations and translations of each scanner.
 pub fn parse(input: &str) -> Vec<Located> {
-    let lines: Vec<_> = input.lines().collect();
-    let mut scanners: Vec<_> = lines.split(|line| line.is_empty()).map(Scanner::parse).collect();
-    locate(&mut scanners)
+    locate(&mut input.split("\n\n").map(Scanner::parse).collect())
 }
 
 /// Calculate the total number of distinct beacons.