Day 8 - Cleanup

src/day8/main.rs

@@ -48,95 +48,15 @@ struct Circuit<'a> {
     set: HashSet<&'a JunctionBox>,
 }
 
-fn sol1(text: &str) {
+/**
-    let boxes: Vec<JunctionBox> = text
+ *
-        .split("\n")
+ * Note this is not a general solution if your anwerser for the first part is in the
-        .filter(|s| s.len() > 0)
+ * happends to be in a merge then this will probably give you the wrong result
-        .map(|s| s.into())
+ *
-        .collect();
+ */
-
-    let mut pairs: Vec<Pair> = Vec::with_capacity(boxes.len() * boxes.len());
-
-    for (i, b1) in boxes.iter().enumerate() {
-        for b2 in boxes.iter().skip(i + 1) {
-            pairs.push(Pair::new(b1, b2))
-        }
-    }
-
-    pairs.sort_by(|a, b| a.dist.total_cmp(&b.dist));
-
-    let mut box_to_circuit: HashMap<&JunctionBox, usize> = HashMap::new();
-    let mut circuits: Vec<Option<Circuit>> = Vec::new();
-
-    for pair in pairs.iter().take(1000) {
-        print!("{} {:?} {:?}", pair.dist, pair.b1, pair.b2);
-        let b1c = box_to_circuit.get(pair.b1);
-        let b2c = box_to_circuit.get(pair.b2);
-        if b1c.is_some() && b2c.is_some() {
-            let b1c = *b1c.unwrap();
-            let b1c_set = circuits[b1c].as_ref().unwrap();
-            if b1c_set.set.contains(pair.b2) {
-                println!(" nothing");
-                continue;
-            }
-            let b2c = *b2c.unwrap();
-            let mut b2c_set: Option<Circuit> = None;
-            std::mem::swap(&mut circuits[b2c], &mut b2c_set);
-            let b2c_set = b2c_set.unwrap();
-            for item in b2c_set.set.iter() {
-                box_to_circuit.insert(item, b1c);
-            }
-            circuits[b1c].as_mut().unwrap().set.extend(&b2c_set.set);
-            println!(" merge");
-        } else if b1c.is_some() {
-            let b1c = *b1c.unwrap();
-            circuits[b1c].as_mut().unwrap().set.insert(pair.b2);
-            box_to_circuit.insert(pair.b2, b1c);
-            println!(" b1");
-        } else if b2c.is_some() {
-            let b2c = *b2c.unwrap();
-            circuits[b2c].as_mut().unwrap().set.insert(pair.b1);
-            box_to_circuit.insert(pair.b1, b2c);
-            println!(" b2");
-        } else {
-            let mut set = HashSet::new();
-            set.insert(pair.b1);
-            set.insert(pair.b2);
-            circuits.push(Some(Circuit { set }));
-            box_to_circuit.insert(pair.b1, circuits.len() - 1);
-            box_to_circuit.insert(pair.b2, circuits.len() - 1);
-            println!(" new");
-        }
-    }
-
-    let mut circuits: Vec<Circuit> = circuits
-        .into_iter()
-        .filter(|s| s.is_some())
-        .map(|a| a.unwrap())
-        .collect();
-
-    circuits.sort_by(|a, b| a.set.len().cmp(&b.set.len()));
-
-    println!("cirt tot: {}", circuits.len());
-    for i in circuits.iter().rev() {
-        println!("cirt: {}", i.set.len());
-    }
-
-    println!(
-        "Sol1: {}",
-        circuits
-            .iter()
-            .rev()
-            .take(3)
-            .fold(1, |m, i| m * i.set.len())
-    );
-}
-
 fn main() -> Result<()> {
     let text = fs::read_to_string("src/day8/act.txt")?;
 
-    sol1(&text);
-
     let boxes: Vec<JunctionBox> = text
         .split("\n")
         .filter(|s| s.len() > 0)
@@ -156,15 +76,15 @@ fn main() -> Result<()> {
     let mut box_to_circuit: HashMap<&JunctionBox, usize> = HashMap::new();
     let mut circuits: Vec<Option<Circuit>> = Vec::new();
 
+    let mut count = 0;
     for pair in pairs.iter() {
-        print!("{} {:?} {:?}", pair.dist, pair.b1, pair.b2);
         let b1c = box_to_circuit.get(pair.b1);
         let b2c = box_to_circuit.get(pair.b2);
         if b1c.is_some() && b2c.is_some() {
             let b1c = *b1c.unwrap();
             let b1c_set = circuits[b1c].as_ref().unwrap();
             if b1c_set.set.contains(pair.b2) {
-                println!(" nothing");
+                count += 1;
                 continue;
             }
             let b2c = *b2c.unwrap();
@@ -177,33 +97,26 @@ fn main() -> Result<()> {
             circuits[b1c].as_mut().unwrap().set.extend(&b2c_set.set);
 
             if circuits[b1c].as_ref().unwrap().set.len() == boxes.len() {
-                println!("\n\nsol2: {}", pair.b1.x * pair.b2.x);
+                println!("Sol2: {}", pair.b1.x * pair.b2.x);
-
                 return Ok(());
             }
-
-            println!(" merge");
         } else if b1c.is_some() {
             let b1c = *b1c.unwrap();
             circuits[b1c].as_mut().unwrap().set.insert(pair.b2);
             box_to_circuit.insert(pair.b2, b1c);
 
             if circuits[b1c].as_ref().unwrap().set.len() == boxes.len() {
-                println!("\n\nsol2: {}", pair.b1.x * pair.b2.x);
+                println!("Sol2: {}", pair.b1.x * pair.b2.x);
-
                 return Ok(());
             }
-            println!(" b1");
         } else if b2c.is_some() {
             let b2c = *b2c.unwrap();
             circuits[b2c].as_mut().unwrap().set.insert(pair.b1);
             box_to_circuit.insert(pair.b1, b2c);
             if circuits[b2c].as_ref().unwrap().set.len() == boxes.len() {
-                println!("\n\nsol2: {}", pair.b1.x * pair.b2.x);
+                println!("Sol2: {}", pair.b1.x * pair.b2.x);
-
                 return Ok(());
             }
-            println!(" b2");
         } else {
             let mut set = HashSet::new();
             set.insert(pair.b1);
@@ -211,8 +124,27 @@ fn main() -> Result<()> {
             circuits.push(Some(Circuit { set }));
             box_to_circuit.insert(pair.b1, circuits.len() - 1);
             box_to_circuit.insert(pair.b2, circuits.len() - 1);
-            println!(" new");
         }
+
+        if count == 1000 {
+            let mut circuits: Vec<&Circuit> = circuits
+                .iter()
+                .filter(|s| s.is_some())
+                .map(|a| a.as_ref().unwrap())
+                .collect();
+
+            circuits.sort_by(|a, b| a.set.len().cmp(&b.set.len()));
+
+            println!(
+                "Sol1: {}",
+                circuits
+                    .iter()
+                    .rev()
+                    .take(3)
+                    .fold(1, |m, i| m * i.set.len())
+            );
+        }
+        count += 1;
     }
 
     panic!("Sould not reach here");