Advent of Code 2025 Day 7

Day 7: Laboratories

https://adventofcode.com/2025/day/7

You are in a teleporter lab without an exit. The input for today is a map of the tachyon manifold of the teleporter, which, surprise, surpise, is broken.

An example input looks like this:

.......S.......
...............
.......^.......
...............
......^.^......
...............
.....^.^.^.....
...............
....^.^...^....
...............
...^.^...^.^...
...............
..^...^.....^..
...............
.^.^.^.^.^...^.
...............

A tachyon beam enters the manifold at S. Tachyon beams always move down.

They pass freely through empty space (.).
They stop and turn into 2 new beams when they encounter a splitter (^).
1. One immediately to the left of the splitter
2. One immediately to the right of the splitter

Helpers

What did you say? Represent a point in 2D space? Point!

#[derive(Debug, Clone, Copy, Hash, Eq, Ord, PartialEq, PartialOrd)]
struct Point {
    row: usize,
    col: usize,
}

Part 1

The question asks how many times the beam will be split.

I represent the manifold as a 2D grid of characters.
A single beam is represented by a Point, the tip of the beam.
All beams are stored in a set.

The set of beams starts with a single point, the starting point.

I loop through that set of beams. Each loop I create a new set of beams, and at the end I replace the old set with the new one. If the new set is empty, the loop ends.

For each beam in the set, I look at the position straight down:

If it’s empty, the beam moves into it.
If it’s a splitter, the beam splits to the left and right of it.

Each time a splitter is encountered the sum gets incremented.

fn part_1(input: &str) -> usize {
    let grid: Vec<Vec<char>> = input.lines().map(|line| line.chars().collect()).collect();
    let rows = grid.len();
    let cols = grid[0].len();
    let start = grid[0].iter().position(|&c| c == 'S').unwrap();

    let mut beams = HashSet::new();
    beams.insert(Point { row: 0, col: start });
    let mut sum = 0;

    while !beams.is_empty() {
        let mut next = HashSet::new();

        for Point { row, col } in beams {
            if row + 1 >= rows {
                continue;
            }
            match grid[row + 1][col] {
                '.' => {
                    let down = Point { row: row + 1, col };
                    next.insert(down);
                }
                '^' => {
                    sum += 1;
                    if col > 0 {
                        let down_left = Point {
                            row: row + 1,
                            col: col - 1,
                        };
                        next.insert(down_left);
                    }
                    if col + 1 < cols {
                        let down_right = Point {
                            row: row + 1,
                            col: col + 1,
                        };
                        next.insert(down_right);
                    }
                }
                _ => unreachable!("Unexpected character in grid"),
            }
        }
        beams = next;
    }

    sum
}

Part 2

It’s a special manifold (because ofcourse it is). Each time a splitter is encountered, time splits in 2, one timeline for each direction the beam took.

The question asks how many timelines are created.

The solution is largely similar to part1. This time, the set of beam heads turns into a map of beam heads where the key is a beam head, and the value is the amount of timelines that head exists in.

The next change is where sum get updated. It gets updated every time a beam falls off the map. When that happens, the amount of timelines (the value in my map) get added to it.

fn part_2(input: &str) -> u64 {
    let grid: Vec<Vec<char>> = input.lines().map(|line| line.chars().collect()).collect();
    let rows = grid.len();
    let cols = grid[0].len();
    let start = grid[0].iter().position(|&c| c == 'S').unwrap();

    let mut beams = HashMap::new();
    beams.insert(Point { row: 0, col: start }, 1);
    let mut sum = 0;

    while !beams.is_empty() {
        let mut next = HashMap::new();

        for (Point { row, col }, count) in beams {
            if row + 1 >= rows {
                sum += count;
                continue;
            }
            match grid[row + 1][col] {
                '.' => {
                    let down = Point { row: row + 1, col };
                    *next.entry(down).or_default() += count;
                }
                '^' => {
                    if col > 0 {
                        let down_left = Point {
                            row: row + 1,
                            col: col - 1,
                        };
                        *next.entry(down_left).or_default() += count;
                    }
                    if col + 1 < cols {
                        let down_right = Point {
                            row: row + 1,
                            col: col + 1,
                        };
                        *next.entry(down_right).or_default() += count;
                    }
                }
                _ => unreachable!("Unexpected character in grid"),
            }
        }
        beams = next;
    }

    sum
}

Final code

1
use std::collections::{HashMap, HashSet};
2

3
#[derive(Debug, Clone, Copy, Hash, Eq, Ord, PartialEq, PartialOrd)]
4
struct Point {
5
    row: usize,
6
    col: usize,
7
}
8

9
fn part_1(input: &str) -> usize {
10
    let grid: Vec<Vec<char>> = input.lines().map(|line| line.chars().collect()).collect();
11
    let rows = grid.len();
12
    let cols = grid[0].len();
13
    let start = grid[0].iter().position(|&c| c == 'S').unwrap();
14

15
    let mut beams = HashSet::new();
16
    beams.insert(Point { row: 0, col: start });
17
    let mut sum = 0;
18

19
    while !beams.is_empty() {
20
        let mut next = HashSet::new();
21

22
        for Point { row, col } in beams {
23
            if row + 1 >= rows {
24
                continue;
25
            }
26
            match grid[row + 1][col] {
27
                '.' => {
28
                    let down = Point { row: row + 1, col };
29
                    next.insert(down);
30
                }
31
                '^' => {
32
                    sum += 1;
33
                    if col > 0 {
34
                        let down_left = Point {
35
                            row: row + 1,
36
                            col: col - 1,
37
                        };
38
                        next.insert(down_left);
39
                    }
40
                    if col + 1 < cols {
41
                        let down_right = Point {
42
                            row: row + 1,
43
                            col: col + 1,
44
                        };
45
                        next.insert(down_right);
46
                    }
47
                }
48
                _ => unreachable!("Unexpected character in grid"),
49
            }
50
        }
51
        beams = next;
52
    }
53

54
    sum
55
}
56

57
fn part_2(input: &str) -> u64 {
58
    let grid: Vec<Vec<char>> = input.lines().map(|line| line.chars().collect()).collect();
59
    let rows = grid.len();
60
    let cols = grid[0].len();
61
    let start = grid[0].iter().position(|&c| c == 'S').unwrap();
62

63
    let mut beams = HashMap::new();
64
    beams.insert(Point { row: 0, col: start }, 1);
65
    let mut sum = 0;
66

67
    while !beams.is_empty() {
68
        let mut next = HashMap::new();
69

70
        for (Point { row, col }, count) in beams {
71
            if row + 1 >= rows {
72
                sum += count;
73
                continue;
74
            }
75
            match grid[row + 1][col] {
76
                '.' => {
77
                    let down = Point { row: row + 1, col };
78
                    *next.entry(down).or_default() += count;
79
                }
80
                '^' => {
81
                    if col > 0 {
82
                        let down_left = Point {
83
                            row: row + 1,
84
                            col: col - 1,
85
                        };
86
                        *next.entry(down_left).or_default() += count;
87
                    }
88
                    if col + 1 < cols {
89
                        let down_right = Point {
90
                            row: row + 1,
91
                            col: col + 1,
92
                        };
93
                        *next.entry(down_right).or_default() += count;
94
                    }
95
                }
96
                _ => unreachable!("Unexpected character in grid"),
97
            }
98
        }
99
        beams = next;
100
    }
101

102
    sum
103
}

Date

Tagged

Part of series

Older post

Newer post