Day 23

Author: BakerNet

README.md

@@ -10,7 +10,7 @@ Solutions for [Advent of Code](https://adventofcode.com/) in [Rust](https://www.
 
 | Year | Completed |
 | :---: | :---: |
-| [2024](aoc2024) | 44/50 |
+| [2024](aoc2024) | 46/50 |
 | [2023](aoc2023) | 50/50 |
 
 ---

aoc2024/README.md

@@ -28,7 +28,7 @@ Solutions for [Advent of Code](https://adventofcode.com/) in [Rust](https://www.
 | [Day 20](https://adventofcode.com/2024/day/20) | [code](src/bin/20.rs) | ⭐ | ⭐ |
 | [Day 21](https://adventofcode.com/2024/day/21) | [code](src/bin/21.rs) | ⭐ | ⭐ |
 | [Day 22](https://adventofcode.com/2024/day/22) | [code](src/bin/22.rs) | ⭐ | ⭐ |
-| [Day 23](https://adventofcode.com/2024/day/23) | [code](src/bin/23.rs) | _ | _ |
+| [Day 23](https://adventofcode.com/2024/day/23) | [code](src/bin/23.rs) | ⭐ | ⭐ |
 | [Day 24](https://adventofcode.com/2024/day/24) | [code](src/bin/24.rs) | _ | _ |
 | [Day 25](https://adventofcode.com/2024/day/25) | [code](src/bin/25.rs) | _ | _ |
 

aoc2024/data/examples/23.txt

@@ -0,0 +1,32 @@
+kh-tc
+qp-kh
+de-cg
+ka-co
+yn-aq
+qp-ub
+cg-tb
+vc-aq
+tb-ka
+wh-tc
+yn-cg
+kh-ub
+ta-co
+de-co
+tc-td
+tb-wq
+wh-td
+ta-ka
+td-qp
+aq-cg
+wq-ub
+ub-vc
+de-ta
+wq-aq
+wq-vc
+wh-yn
+ka-de
+kh-ta
+co-tc
+wh-qp
+tb-vc
+td-yn

aoc2024/src/bin/23.rs

@@ -0,0 +1,122 @@
+use std::collections::{HashMap, HashSet};
+
+advent_of_code::solution!(23);
+
+fn parse_input(input: &str) -> HashMap<&str, Vec<&str>> {
+    let mut cons: HashMap<&str, Vec<&str>> = HashMap::new();
+    input.lines().for_each(|l| {
+        let comps = l.split_once("-").expect("Split should work");
+        cons.entry(comps.0)
+            .and_modify(|v| v.push(comps.1))
+            .or_insert(vec![comps.1]);
+        cons.entry(comps.1)
+            .and_modify(|v| v.push(comps.0))
+            .or_insert(vec![comps.0]);
+    });
+    cons
+}
+
+pub fn part_one(input: &str) -> Option<u64> {
+    let cons = parse_input(input);
+    let mut threes = HashSet::new();
+    cons.iter()
+        .filter(|x| x.0.starts_with("t"))
+        .for_each(|(&k, v)| {
+            v.iter().for_each(|&k2| {
+                cons.get(k2)
+                    .unwrap()
+                    .iter()
+                    .filter(|&&k3| k3 != k)
+                    .for_each(|&k3| {
+                        if cons.get(k3).unwrap().contains(&k) {
+                            let mut new = [k, k2, k3];
+                            new.sort();
+                            threes.insert(new);
+                        }
+                    })
+            })
+        });
+    Some(threes.len() as u64)
+}
+
+fn largest_containing<'a>(
+    containing: Vec<&'a str>,
+    tried_containing: &mut HashSet<String>,
+    cons: &'a HashMap<&'a str, Vec<&'a str>>,
+) -> String {
+    let item = containing.iter().next().unwrap();
+    let v = cons.get(item).unwrap();
+    let res = v
+        .iter()
+        .filter_map(|&k| {
+            if containing.contains(&k) {
+                return None;
+            }
+            let other_v = cons.get(k).unwrap();
+            for j in containing.iter() {
+                if !other_v.contains(j) {
+                    return None;
+                }
+            }
+            let mut new_containing = containing.clone();
+            new_containing.push(k);
+            new_containing.sort();
+            let as_string = new_containing.join(",");
+            if tried_containing.contains(&as_string) {
+                return None;
+            }
+            tried_containing.insert(as_string);
+            Some(largest_containing(new_containing, tried_containing, cons))
+        })
+        .fold(
+            String::new(),
+            |acc, s| {
+                if s.len() > acc.len() {
+                    s
+                } else {
+                    acc
+                }
+            },
+        );
+    if res.is_empty() {
+        containing.join(",")
+    } else {
+        res
+    }
+}
+
+pub fn part_two(input: &str) -> Option<String> {
+    let cons = parse_input(input);
+    let mut seen_sets = HashSet::new();
+    let largest = cons
+        .keys()
+        .map(|&k| largest_containing(vec![k], &mut seen_sets, &cons))
+        .fold(
+            String::new(),
+            |acc, s| {
+                if s.len() > acc.len() {
+                    s
+                } else {
+                    acc
+                }
+            },
+        );
+    Some(largest)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_part_one() {
+        let result = part_one(&advent_of_code::template::read_file("examples", DAY));
+        assert_eq!(result, Some(7));
+    }
+
+    #[test]
+    fn test_part_two() {
+        let result = part_two(&advent_of_code::template::read_file("examples", DAY));
+        assert_eq!(result, Some("co,de,ka,ta".to_string()));
+    }
+}