a bunch of crap that's probably worthless

2021/src/day8.rs

@@ -31,40 +31,66 @@ impl Segment {
             _ => Err(eyre!("Invalid character for segment: {}", c)),
         }
     }
+
+    fn to_ord(&self) -> usize {
+        // kinda gross but whatever
+        match self {
+            A => 0, B => 1, C => 2, D => 3,
+            E => 4, F => 5, G => 6
+        }
+    }
+
+    fn from_value(n: u8) -> eyre::Result<Self> {
+        match n {
+            1 => Ok(A),
+            2 => Ok(B),
+            4 => Ok(C),
+            8 => Ok(D),
+            16 => Ok(E),
+            32 => Ok(F),
+            64 => Ok(G),
+            _ => Err(eyre!("Invalid value for segment: {}", n)),
+        }
+    }
 }
 
 
-#[derive(Default, Debug)]
+#[derive(Copy, Clone, Default, Debug)]
 struct SegmentSet {
     data: u8,
-    len: u8,
 }
 
 impl SegmentSet {
+    fn new_filled() -> Self {
+        SegmentSet {data: 255}
+    }
+
     fn contains(&self, segment: Segment) -> bool {
         self.data & (segment as u8) > 0
     }
 
     fn insert(&mut self, segment: Segment) {
         self.data |= segment as u8;
-        self.len += 1;
     }
 
     fn remove(&mut self, segment: Segment) {
         self.data ^= segment as u8;
-        self.len -= 1
     }
 
     fn len(&self) -> u8 {
-        self.len
+        (0..7).fold(0, |total, i| total + ((self.data >> i) & 1))
     }
 
     fn union(&self, other: &Self) -> Self {
-        self.data | other.data
+        SegmentSet {data: self.data | other.data}
     }
 
     fn intersect(&self, other: &Self) -> Self {
-        self.data & other.data
+        SegmentSet {data: self.data & other.data}
+    }
+
+    fn iter(&self) -> SegmentSetIter {
+        SegmentSetIter {ss: self, pos: 0}
     }
 }
 
@@ -80,6 +106,26 @@ impl FromStr for SegmentSet {
 }
 
 
+struct SegmentSetIter<'a> {
+    ss: &'a SegmentSet,
+    pos: u8,
+}
+
+impl Iterator for SegmentSetIter<'_> {
+    type Item = Segment;
+    fn next(&mut self) -> Option<Segment> {
+        while self.pos < 7 {
+            let seg_value = self.ss.data & (1 << self.pos);
+            self.pos += 1;
+            if seg_value > 0 {
+                return Some(Segment::from_value(seg_value).unwrap());
+            }
+        }
+        return None
+    }
+}
+
+
 #[derive(Default, Debug)]
 struct Screen {
     patterns: [SegmentSet; 10],
@@ -103,21 +149,27 @@ impl FromStr for Screen {
 }
 
 
-const DIGIT_SEGMENTS = {
-    let segment_strs = [
-        "abcefg", "cf", "acdeg", "acdfg",
-        "bcdf", "abdfg", "abdefg", "acf",
-        "abcdefg", "abcdfg",
-    ]
-
-    let sets = [SegmentSet::default(), 10]
-    for (i, s) in segment_strs.iter().enumerate() {
-        sets[i] = s.parse::<SegmentSet>().unwrap()
-    }
-    sets
+// mapping of Segment -> SegmentSet, represents 
+struct Candidates {
+    signal: Segment,
+    possible: SegmentSet
 }
 
 
+const DIGIT_SEGMENTS: [SegmentSet; 10] = [ // magic numbers, fun!
+    SegmentSet {data: 0b01110111},
+    SegmentSet {data: 0b00100100},
+    SegmentSet {data: 0b01011101},
+    SegmentSet {data: 0b01101101},
+    SegmentSet {data: 0b00101110},
+    SegmentSet {data: 0b01101011},
+    SegmentSet {data: 0b01111011},
+    SegmentSet {data: 0b00100101},
+    SegmentSet {data: 0b01111111},
+    SegmentSet {data: 0b01101111},
+];
+
+
 fn part1(screens: &[Screen]) -> usize {
     screens.iter()
         .flat_map(|d| d.output.iter())
@@ -131,5 +183,7 @@ pub fn run(data: &str) -> eyre::Result<(usize, usize)> {
         .parse_lines::<Screen>()
         .collect::<Result<Vec<_>, _>>()?;
 
+
+
     Ok((part1(&screens), 0))
 }