Add day 17

Author: LiquidFun

2020/17/17.rs

@@ -1,48 +1,57 @@
 use std::{collections::HashSet, io::stdin};
 
-use itertools::Itertools;
+use itertools::{iproduct, Itertools};
 
-fn adjacent(xyz: (i32, i32, i32, i32)) -> HashSet<(i32, i32, i32, i32)> {
-    (-1..=1)
-        .cartesian_product(-1..=1)
-        .cartesian_product(-1..=1)
-        .cartesian_product(-1..=1)
-        .map(|(((x, y), z), w)| (x + xyz.0, y + xyz.1, z + xyz.2, w+xyz.3))
-        .collect()
-}
+fn adjacent(p: &Vec<i32>) -> HashSet<Vec<i32>> {
+    let r = [-1, 0, 1];
 
-fn main() {
-    let mut active = stdin()
-        .lines()
-        .enumerate()
-        .map(|(y, line)| {
-            line.unwrap()
-                .chars()
-                .enumerate()
-                .filter(|(_, c)| *c == '#')
-                .map(|(x, _)| (y as i32, x as i32, 0, 0))
-                .collect_vec()
-        })
-        .flatten()
-        .collect::<HashSet<_>>();
-    println!("{:?}", active);
+    match p.len() {
+        3 => iproduct!(r, r, r)
+            .map(|(dx, dy, dz)| vec![p[0] + dx, p[1] + dy, p[2] + dz])
+            .collect(),
+        4 => iproduct!(r, r, r, r)
+            .map(|(dx, dy, dz, dw)| vec![p[0] + dx, p[1] + dy, p[2] + dz, p[3] + dw])
+            .collect(),
+        _ => HashSet::new(),
+    }
+}
 
-    println!("{:?}", active.len());
+fn solve(initial_active: HashSet<Vec<i32>>) {
+    let mut active = initial_active;
     for _ in 0..6 {
         let mut new_active = HashSet::new();
         let mut inactive = HashSet::new();
         for xyz in active.iter() {
-            inactive.extend(adjacent(*xyz).difference(&active));
-            if (3..=4).contains(&adjacent(*xyz).intersection(&active).count()) {
-                new_active.insert(*xyz);
+            let adj = adjacent(xyz);
+            inactive.extend(adj.difference(&active).cloned());
+            if (3..=4).contains(&adj.intersection(&active).count()) {
+                new_active.insert(xyz.to_vec());
             }
         }
         for xyz in inactive.iter() {
-            if adjacent(*xyz).intersection(&active).count() == 3 {
-                new_active.insert(*xyz);
+            if adjacent(xyz).intersection(&active).count() == 3 {
+                new_active.insert(xyz.to_vec());
             }
         }
         active = new_active;
-        println!("{:?}", active.len());
     }
+    println!("{:?}", active.len());
 }
+
+fn main() {
+    let active = stdin()
+        .lines()
+        .enumerate()
+        .map(|(y, line)| {
+            line.unwrap()
+                .chars()
+                .enumerate()
+                .filter(|(_, c)| *c == '#')
+                .map(|(x, _)| vec![y as i32, x as i32, 0])
+                .collect_vec()
+        })
+        .flatten()
+        .collect::<HashSet<_>>();
+    solve(active.clone());
+    solve(active.iter().map(|v| v.iter().cloned().chain(vec![4]).collect()).collect());
+}