Day 8 - Cleanup

src/day8/main.rs

@@ -48,7 +48,15 @@ struct Circuit<'a> {
     set: HashSet<&'a JunctionBox>,
 }
 
-fn sol1(text: &str) {
+/**
+ *
+ * Note this is not a general solution if your anwerser for the first part is in the
+ * happends to be in a merge then this will probably give you the wrong result
+ *
+ */
+fn main() -> Result<()> {
+    let text = fs::read_to_string("src/day8/act.txt")?;
+
     let boxes: Vec<JunctionBox> = text
         .split("\n")
         .filter(|s| s.len() > 0)
@@ -68,15 +76,15 @@ fn sol1(text: &str) {
     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 mut count = 0;
+    for pair in pairs.iter() {
         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();
@@ -87,17 +95,28 @@ fn sol1(text: &str) {
                 box_to_circuit.insert(item, b1c);
             }
             circuits[b1c].as_mut().unwrap().set.extend(&b2c_set.set);
-            println!(" merge");
+
+            if circuits[b1c].as_ref().unwrap().set.len() == boxes.len() {
+                println!("Sol2: {}", pair.b1.x * pair.b2.x);
+                return Ok(());
+            }
         } 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");
+
+            if circuits[b1c].as_ref().unwrap().set.len() == boxes.len() {
+                println!("Sol2: {}", pair.b1.x * pair.b2.x);
+                return Ok(());
+            }
         } 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");
+            if circuits[b2c].as_ref().unwrap().set.len() == boxes.len() {
+                println!("Sol2: {}", pair.b1.x * pair.b2.x);
+                return Ok(());
+            }
         } else {
             let mut set = HashSet::new();
             set.insert(pair.b1);
@@ -105,23 +124,17 @@ fn sol1(text: &str) {
             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()
+        if count == 1000 {
+            let mut circuits: Vec<&Circuit> = circuits
+                .iter()
                 .filter(|s| s.is_some())
-        .map(|a| a.unwrap())
+                .map(|a| a.as_ref().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
@@ -131,88 +144,7 @@ fn sol1(text: &str) {
                     .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)
-        .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() {
-        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);
-
-            if circuits[b1c].as_ref().unwrap().set.len() == boxes.len() {
-                println!("\n\nsol2: {}", 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);
-
-                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);
-
-                return Ok(());
-            }
-            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");
-        }
+        count += 1;
     }
 
     panic!("Sould not reach here");