day 6

src/day6.rs

@@ -0,0 +1,76 @@
+use std::{iter::FromIterator, ops::BitAnd};
+
+use aoc_runner_derive::aoc;
+
+/// A set that can only contain b'a'..b'z';
+struct AlphabetSet(u32);
+impl AlphabetSet {
+    pub fn new() -> AlphabetSet {
+        AlphabetSet(0)
+    }
+
+    pub fn insert(&mut self, b: u8) {
+        self.0 |= 1 << Self::char_to_bit_index(b);
+    }
+
+    pub fn len(&self) -> usize {
+        self.0.count_ones() as usize
+    }
+
+    fn char_to_bit_index(b: u8) -> usize {
+        debug_assert!(b >= b'a' && b <= b'z');
+        (b as usize - 97) & 0x1f
+    }
+}
+
+// Do a set intersection with another set.
+impl std::ops::BitAndAssign for AlphabetSet {
+    fn bitand_assign(&mut self, rhs: AlphabetSet) {
+        self.0 &= rhs.0;
+    }
+}
+
+impl FromIterator<u8> for AlphabetSet {
+    fn from_iter<I>(iter: I) -> AlphabetSet
+    where
+        I: IntoIterator<Item = u8>,
+    {
+        let mut set = AlphabetSet::new();
+        for entry in iter {
+            set.insert(entry);
+        }
+        set
+    }
+}
+
+#[aoc(day6, part1)]
+pub fn solve_d6_p1(input: &str) -> usize {
+    input
+        .split("\n\n")
+        .map(|record| {
+            record
+                .split('\n')
+                .flat_map(|line| line.as_bytes())
+                .copied()
+                .collect::<AlphabetSet>()
+                .len()
+        })
+        .sum()
+}
+
+#[aoc(day6, part2)]
+pub fn solve_d6_p2(input: &str) -> usize {
+    input
+        .split("\n\n")
+        .map(|record| {
+            let mut line_iter = record
+                .split('\n')
+                .map(|line| line.as_bytes().iter().copied().collect::<AlphabetSet>());
+            let mut group_set = line_iter.next().unwrap();
+            for set in line_iter {
+                group_set &= set;
+            }
+            group_set.len()
+        })
+        .sum()
+}

src/lib.rs

@@ -3,5 +3,6 @@ pub mod day2;
 pub mod day3;
 pub mod day4;
 pub mod day5;
+pub mod day6;
 
 aoc_runner_derive::aoc_lib! { year = 2020 }