2025 Day 8 and a couple 2015

Author: BakerNet

README.md

@@ -10,10 +10,10 @@ Solutions for [Advent of Code](https://adventofcode.com/) in [Rust](https://www.
 
 | Year | Completed |
 | :---: | :---: |
-| [2025](aoc2025) | 14/24 |
+| [2025](aoc2025) | 16/24 |
 | [2024](aoc2024) | 50/50 |
 | [2023](aoc2023) | 50/50 |
-| [2015](aoc2015) | 20/50 |
+| [2015](aoc2015) | 24/50 |
 
 ---
 

aoc2015/README.md

@@ -16,8 +16,8 @@ Solutions for [Advent of Code](https://adventofcode.com/) in [Rust](https://www.
 | [Day 8](https://adventofcode.com/2024/day/8) | [code](src/bin/08.rs) | ⭐ | ⭐ |
 | [Day 9](https://adventofcode.com/2024/day/9) | [code](src/bin/09.rs) | ⭐ | ⭐ |
 | [Day 10](https://adventofcode.com/2024/day/10) | [code](src/bin/10.rs) | ⭐ | ⭐ |
-| [Day 11](https://adventofcode.com/2024/day/11) | [code](src/bin/11.rs) | _ | _ |
-| [Day 12](https://adventofcode.com/2024/day/12) | [code](src/bin/12.rs) | _ | _ |
+| [Day 11](https://adventofcode.com/2024/day/11) | [code](src/bin/11.rs) | ⭐ | ⭐ |
+| [Day 12](https://adventofcode.com/2024/day/12) | [code](src/bin/12.rs) | ⭐ | ⭐ |
 | [Day 13](https://adventofcode.com/2024/day/13) | [code](src/bin/13.rs) | _ | _ |
 | [Day 14](https://adventofcode.com/2024/day/14) | [code](src/bin/14.rs) | _ | _ |
 | [Day 15](https://adventofcode.com/2024/day/15) | [code](src/bin/15.rs) | _ | _ |

aoc2015/data/examples/11.txt

@@ -0,0 +1 @@
+{"e":[1,2,3],"f":{"a":2,"b":4},"g":[[[3]]],"h":{"a":{"b":4},"c":-1,"d":"red"},"i":{"a":[-1,1]},"j":[-1,{"a":1}],"k":[],"l":{}}

aoc2015/data/examples/12.txt

@@ -0,0 +1,33 @@
+advent_of_code::solution!(11);
+
+pub fn part_one(_input: &str) -> Option<&str> {
+    // this one was way too easy to eyeball.  Might come back and code, might not
+    // input was 'cqjxjnds' - first 3 are valid but don't hit requirements, so last 5 become 'xxyzz'
+    Some("cqjxxyzz")
+}
+
+pub fn part_two(_input: &str) -> Option<&str> {
+    // this one was also way too easy.
+    // `cqjxxyzz`++ -> `cqjxxzzz` - have to bump up `j` -> `k` (still valid) so last 5 become
+    // `aabcc`
+    Some("cqkaabcc")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_part_one() {
+        let contents = &advent_of_code::template::read_file("examples", DAY);
+        let result = part_one(&contents);
+        assert_eq!(result, Some("cqjxxyzz"));
+    }
+
+    #[test]
+    fn test_part_two() {
+        let contents = &advent_of_code::template::read_file("examples", DAY);
+        let result = part_two(&contents);
+        assert_eq!(result, Some("cqkaabcc"));
+    }
+}

aoc2015/src/bin/11.rs

@@ -0,0 +1,122 @@
+advent_of_code::solution!(12);
+
+pub fn part_one(input: &str) -> Option<i64> {
+    let total = input
+        .split(['[', ']', '{', '}', ',', ':'])
+        .filter_map(|s| s.parse::<i64>().ok())
+        .sum();
+    Some(total)
+}
+
+fn parse_object(input: &str, index: usize) -> (i64, usize) {
+    let mut index = index;
+    let mut s = String::new();
+    let bytes = input.as_bytes();
+    let mut total = 0;
+    loop {
+        let c = bytes[index];
+        match c {
+            b',' => {
+                if s == "\"red\"" {
+                    // drain until end of object
+                    let mut depth = 1;
+                    while depth != 0 {
+                        index += 1;
+                        match bytes[index] {
+                            b'{' => depth += 1,
+                            b'}' => depth -= 1,
+                            _ => (),
+                        }
+                    }
+                    return (0, index);
+                }
+                if let Ok(x) = s.parse::<i64>() {
+                    total += x;
+                }
+                s.clear();
+            }
+            b':' => {
+                s.clear();
+            }
+            b'{' => {
+                let (add_t, new_index) = parse_object(input, index + 1);
+                total += add_t;
+                index = new_index;
+            }
+            b'[' => {
+                let (add_t, new_index) = parse_list(input, index + 1);
+                total += add_t;
+                index = new_index;
+            }
+            b'}' => {
+                if s == "\"red\"" {
+                    return (0, index);
+                }
+                if let Ok(x) = s.parse::<i64>() {
+                    total += x;
+                }
+                return (total, index);
+            }
+            other => s.push(other as char),
+        }
+        index += 1;
+    }
+}
+
+fn parse_list(input: &str, index: usize) -> (i64, usize) {
+    let mut index = index;
+    let mut s = String::new();
+    let bytes = input.as_bytes();
+    let mut total = 0;
+    loop {
+        let c = bytes[index];
+        match c {
+            b',' => {
+                if let Ok(x) = s.parse::<i64>() {
+                    total += x;
+                }
+                s.clear();
+            }
+            b'{' => {
+                let (add_t, new_index) = parse_object(input, index + 1);
+                total += add_t;
+                index = new_index;
+            }
+            b'[' => {
+                let (add_t, new_index) = parse_list(input, index + 1);
+                total += add_t;
+                index = new_index;
+            }
+            b']' => {
+                if let Ok(x) = s.parse::<i64>() {
+                    total += x;
+                }
+                return (total, index);
+            }
+            other => s.push(other as char),
+        }
+        index += 1;
+    }
+}
+
+pub fn part_two(input: &str) -> Option<i64> {
+    let (total, _) = parse_object(input, 1);
+    Some(total)
+}
+
+#[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(18));
+    }
+
+    #[test]
+    fn test_part_two() {
+        let result = part_two(&advent_of_code::template::read_file("examples", DAY));
+        assert_eq!(result, Some(15));
+    }
+}

aoc2015/src/bin/12.rs

@@ -13,7 +13,7 @@ Solutions for [Advent of Code](https://adventofcode.com/) in [Rust](https://www.
 | [Day 5](https://adventofcode.com/2025/day/5) | [code](src/bin/05.rs) | ⭐ | ⭐ |
 | [Day 6](https://adventofcode.com/2025/day/6) | [code](src/bin/06.rs) | ⭐ | ⭐ |
 | [Day 7](https://adventofcode.com/2025/day/7) | [code](src/bin/07.rs) | ⭐ | ⭐ |
-| [Day 8](https://adventofcode.com/2025/day/8) | [code](src/bin/08.rs) | _ | _ |
+| [Day 8](https://adventofcode.com/2025/day/8) | [code](src/bin/08.rs) | ⭐ | ⭐ |
 | [Day 9](https://adventofcode.com/2025/day/9) | [code](src/bin/09.rs) | _ | _ |
 | [Day 10](https://adventofcode.com/2025/day/10) | [code](src/bin/10.rs) | _ | _ |
 | [Day 11](https://adventofcode.com/2025/day/11) | [code](src/bin/11.rs) | _ | _ |

aoc2025/README.md

@@ -0,0 +1,20 @@
+162,817,812
+57,618,57
+906,360,560
+592,479,940
+352,342,300
+466,668,158
+542,29,236
+431,825,988
+739,650,466
+52,470,668
+216,146,977
+819,987,18
+117,168,530
+805,96,715
+346,949,466
+970,615,88
+941,993,340
+862,61,35
+984,92,344
+425,690,689

aoc2025/data/examples/08.txt

@@ -0,0 +1,144 @@
+use std::{
+    collections::{HashMap, HashSet},
+    mem,
+};
+
+use aoc_utils::*;
+use itertools::Itertools;
+
+advent_of_code::solution!(8);
+
+fn handle_conn(
+    p1: (u64, u64, u64),
+    p2: (u64, u64, u64),
+    circuits: &mut Vec<HashSet<(u64, u64, u64)>>,
+    point_to_circuit: &mut HashMap<(u64, u64, u64), usize>,
+) -> usize {
+    let first_p2c = point_to_circuit.get(&p1);
+    let second_p2c = point_to_circuit.get(&p2);
+    let mut check_circ = 0;
+    match (first_p2c, second_p2c) {
+        (None, None) => {
+            let circuit_id = circuits.len() - 1;
+            circuits[circuit_id].insert(p1);
+            circuits[circuit_id].insert(p2);
+            point_to_circuit.insert(p1, circuit_id);
+            point_to_circuit.insert(p2, circuit_id);
+            circuits.push(HashSet::new());
+        }
+        (None, Some(b)) => {
+            let b = *b;
+            circuits[b].insert(p1);
+            point_to_circuit.insert(p1, b);
+            check_circ = b;
+        }
+        (Some(a), None) => {
+            let a = *a;
+            circuits[a].insert(p2);
+            point_to_circuit.insert(p2, a);
+            check_circ = a;
+        }
+        (Some(a), Some(b)) => {
+            let a = a.to_owned();
+            let b = b.to_owned();
+            if a != b {
+                // merge curcuits
+                let mut circ_to_merge = HashSet::new();
+                mem::swap(&mut circ_to_merge, &mut circuits[b]);
+                for p in circ_to_merge.into_iter() {
+                    circuits[a].insert(p);
+                    point_to_circuit.insert(p, a);
+                }
+            }
+            check_circ = a
+        }
+    }
+    check_circ
+}
+
+fn distance(a: (u64, u64, u64), b: (u64, u64, u64)) -> u64 {
+    // hopefully manhattan distance works
+    let x = a.0.abs_diff(b.0).pow(2);
+    let y = a.1.abs_diff(b.1).pow(2);
+    let z = a.2.abs_diff(b.2).pow(2);
+    (x + y + z).isqrt()
+}
+
+pub fn part_one(input: &str) -> Option<u64> {
+    let points = input.mlines(|s| {
+        s.split(",")
+            .map(|n| n.parse::<u64>().expect("Should get int"))
+            .collect_tuple::<(u64, u64, u64)>()
+            .expect("Should get 3d point")
+    });
+    let total_points = points.len();
+
+    let mut circuits = Vec::<HashSet<(u64, u64, u64)>>::with_capacity(total_points);
+    circuits.push(HashSet::new());
+    let mut point_to_circuit = HashMap::<(u64, u64, u64), usize>::new();
+
+    #[cfg(test)]
+    let num_conns = 10;
+    #[cfg(not(test))]
+    let num_conns = 1000;
+    let conns = points
+        .into_iter()
+        .tuple_combinations()
+        .sorted_by_key(|(a, b)| distance(*a, *b))
+        .take(num_conns);
+    for c in conns {
+        let _ = handle_conn(c.0, c.1, &mut circuits, &mut point_to_circuit);
+    }
+    Some(
+        circuits
+            .iter()
+            .map(|s| s.len())
+            .sorted()
+            .rev()
+            .take(3)
+            .product::<usize>() as u64,
+    )
+}
+
+pub fn part_two(input: &str) -> Option<u64> {
+    let points = input.mlines(|s| {
+        s.split(",")
+            .map(|n| n.parse::<u64>().expect("Should get int"))
+            .collect_tuple::<(u64, u64, u64)>()
+            .expect("Should get 3d point")
+    });
+    let total_points = points.len();
+
+    let mut circuits = Vec::<HashSet<(u64, u64, u64)>>::with_capacity(total_points);
+    circuits.push(HashSet::new());
+    let mut point_to_circuit = HashMap::<(u64, u64, u64), usize>::new();
+
+    let conns = points
+        .into_iter()
+        .tuple_combinations()
+        .sorted_by_key(|(a, b)| distance(*a, *b));
+    for c in conns {
+        let check_circ = handle_conn(c.0, c.1, &mut circuits, &mut point_to_circuit);
+        if circuits[check_circ].len() == total_points {
+            return Some(c.0 .0 * c.1 .0);
+        }
+    }
+    None
+}
+
+#[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(40));
+    }
+
+    #[test]
+    fn test_part_two() {
+        let result = part_two(&advent_of_code::template::read_file("examples", DAY));
+        assert_eq!(result, Some(25272));
+    }
+}