Add day 7 part 2 + refactor day 1

bram/rust/src/day_07/mod.rs

@@ -1,107 +1,67 @@
 use crate::utils;
+use std::collections::HashMap;
 
-pub fn answer(text : String) -> ( u16, u16 ) {
-    ( text.trim()
+pub fn answer(text : String) -> ( u16, u64 ) {
+    let tachyons: TachyonLayer = text.trim()
         .split_whitespace()
-        .fold(TachyonLayer::new(), |tl, s| tl.next_layer(s))
-        .splits
-    // 71 incorrect
-    // 1652 too high
-    , 0
+        .fold(
+            TachyonLayer::new(),
+            |tl, s| tl.next_layer(s)
+        );
+    
+    ( tachyons.splits
+    , tachyons.beams.values().sum()
     )
 }
 
 struct TachyonLayer {
-    beams : Vec<u8>,
-    layer: u8,
+    beams : HashMap<usize, u64>,
     splits : u16,
 }
 impl TachyonLayer {
+    fn get(&self, x : &usize) -> &u64 {
+        self.beams.get(x).unwrap_or(&0)
+    }
+
+    fn insert(&mut self, x : usize, amount : u64) {
+        self.beams
+            .entry(x)
+            .and_modify(|v| *v += amount)
+            .or_insert(amount);
+    }
+
     fn new() -> TachyonLayer {
         TachyonLayer {
-            beams : Vec::new(),
-            layer : 0,
+            beams : HashMap::new(),
             splits : 0,
         }
     }
 
     fn next_layer(&self, manifold : &str) -> TachyonLayer {
-        // println!("----------------------------------");
-        // println!("Old layer looks like: {:?}", self.beams);
+        let mut new_beams = TachyonLayer::new();
+        new_beams.splits += self.splits;
 
-        // Currently tracked beams
-        // The list is sorted to make iteration easier
-        let mut beam_i: usize = 0;
-        let mut beam: Option<u8> = self.beams.get(beam_i).map(|&b| b);
-
-        // Last pushed beam, to avoid duplicates
-        let mut latest_push: Option<usize> = None;
-
-        // New Layer data
-        let mut new: Vec<u8> = Vec::new();
-        let mut splits: u16 = self.splits;
-
-        // Loop over the manifold string
-        for (i, c) in manifold.chars().enumerate() {
+        for (x, c) in manifold.chars().enumerate() {
             match c {
+                'S' => {
+                    new_beams.insert(x, 1);
+                },
                 '.' => {
-                    if let Some(b) = beam {
-                        if i == usize::from(b) {
-                            if let Some(lp) = latest_push {
-                                if i == lp {} else {
-                                    new.push(b);
-                                }
-                            } else {
-                                new.push(b);
-                            }
-                            
-                            beam_i += 1;
-                            beam = self.beams.get(beam_i).map(|&b| b);
-                            
-                            latest_push = Some(i);
-                        }
-                    }
+                    new_beams.insert(x, *self.get(&x));
                 },
                 '^' => {
-                    if let Some(b) = beam {
-                        if i == usize::from(b) {
-                            if let Some(lp) = latest_push {
-                                if i - 1 == lp {} else {
-                                    new.push(b-1);
-                                }
-                            } else {
-                                new.push(b-1);
-                            }
-                            new.push(b+1);
+                    let &rays: &u64 = self.get(&x);
 
-                            beam_i += 1;
-                            beam = self.beams.get(beam_i).map(|&b| b);
-
-                            latest_push = Some(i+1);
-                            splits += 1;
-
-                            // println!("Encountered split #{} at x={} and y={}", splits, i, self.layer);
-                        }
+                    if rays > 0 {
+                        new_beams.splits += 1;
+                        new_beams.insert(x - 1, rays);
+                        new_beams.insert(x + 1, rays);
                     }
                 },
-                'S' => {
-                    new.push(i as u8);
-                    latest_push = Some(i);
-
-                    if let Some(b) = beam {
-                        if i == usize::from(b) {
-                            beam_i += 1;
-                            beam = self.beams.get(beam_i).map(|&b| b);
-                        }
-                    }
-                },
-                _ => {
-                    panic!("Encountered unexpected input char")
-                },
+                _ => {},
             }
         }
 
-        // println!("New layer looks like: {:?}", new);
-        TachyonLayer { beams: new, layer : self.layer + 1, splits: splits }
+        new_beams
     }
 }