Advent of Code 2025 Day 10

Day 10: Factory

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

You are standing in a large movie factory filled with machine.

The input for today is a list of information about those machines.

An example input looks like this:

[.##.] (3) (1,3) (2) (2,3) (0,2) (0,1) {3,5,4,7}
[...#.] (0,2,3,4) (2,3) (0,4) (0,1,2) (1,2,3,4) {7,5,12,7,2}
[.###.#] (0,1,2,3,4) (0,3,4) (0,1,2,4,5) (1,2) {10,11,11,5,10,5}

Each line is a machine.

The part in square bois [] represents the target indicator lights state, they are on # or off ..

The parts in round bois () represents the buttons on the machine.

The part in curly bois {} represents the target joltage levels.

Parsing

Each line gets parsed into a Machine.

The target lights state is a list of booleans
The target joltage state is a list of numbers.
The buttons are a list of lists of indexes.

#[derive(Debug, Clone)]
struct Machine {
    lights: Vec<bool>,
    buttons: Vec<Vec<usize>>,
    jolts: Vec<u32>,
}

fn parse(input: &str) -> Vec<Machine> {
    input.lines().map(|line| {
        let (lights_str, rest) = line.split_once(' ').unwrap();
        let (buttons_str, jolts_str) = rest.rsplit_once(' ').unwrap();

        let lights = lights_str
            .trim_matches(['[', ']'])
            .chars()
            .map(|c| c == '#')
            .collect();

        let buttons = buttons_str
            .split(' ')
            .map(|s| {
                s.trim_matches(['(', ')'])
                    .split(',')
                    .map(|s| s.parse().unwrap())
                    .collect()
            })
            .collect();

        let jolts = jolts_str
            .trim_matches(['{', '}'])
            .split(',')
            .map(|s| s.parse().unwrap())
            .collect();

        Machine {
            lights,
            buttons,
            jolts,
        }
    })
}

Part 1

Each machine starts off, all the indicator lights are off.

Each button affects a list of lights.

For instance if a button has the list (0, 2, 3) pressing it would toggle the indicator lights at index 0, 2, and 3.

The question asks for the minimum amount of button presses that sets the lights like the goal ones in the input.

The part solving function is fairly boring, it’s the helper where interesting things happen.

It’s a classic BFS that stops once the state matches the target. As a bonus I convert the target list of light states into a single number, the lights the buttons affect also get turned into a single number per button.

That way, I can toggle all lights a button affects at once by XORing it with the current state of the lights.

impl Machine {
    fn min_presses_lights(&self) -> usize {
        let goal: u32 =
            self.lights
                .iter()
                .enumerate()
                .fold(0, |acc, (i, &on)| if on { acc | (1 << i) } else { acc });
        let buttons: Vec<u32> = self
            .buttons
            .iter()
            .map(|idxs| idxs.iter().fold(0, |acc, &idx| acc | (1 << idx)))
            .collect();

        // queue of (curr_lights, num_presses)
        let mut q = VecDeque::from([(0, 0)]);
        let mut seen = HashSet::from([0]);

        while let Some((lights, presses)) = q.pop_front() {
            if lights == goal {
                return presses;
            }
            for button in &buttons {
                let next = lights ^ button;
                if seen.insert(next) {
                    q.push_back((next, presses + 1));
                }
            }
        }

        0
    }
}

fn part_1(input: &str) -> usize {
    parse(input).iter().map(|m| m.min_presses_lights()).sum()
}

Part 2

The machines are on!
Now you need to bring them up to their exact joltage requirements.

The buttons now no longer affect the lights, but they increment a joltage counter.

Every counter starts at 0.
Every press of a button that affects a counter at that index increases it by 1.

The question asks for the minimum amount of button presses that sets the joltage levels like the goal ones in the input.

The part solving function is fairly boring, it’s the helper where interesting things happen.

It uses a linear algebra solving package.

The package I used is called good_lp.

I used the default solver, and don’t want it to depend on anything being installed on my machine.

good_lp = { version = "1.14.2", features = ["minilp"], default-features = false }

impl Machine {
    fn min_presses_jolts(&self) -> u32 {
        use good_lp::*;

        // create variable per button (number of times it got pressed)
        let mut vars = variables!();
        let presses: Vec<Variable> = (0..self.buttons.len())
            .map(|_| vars.add(variable().min(0).integer()))
            .collect();

        // minimize total presses
        let total_presses: Expression = presses.iter().sum();
        let mut problem = vars.minimise(total_presses).using(default_solver);

        // for each jolt counter, sum of relevant presses must equal the target joltage
        for (jolt_idx, &target) in self.jolts.iter().enumerate() {
            let mut expr = Expression::from(0.0);

            for (btn_idx, relevant_idxs) in self.buttons.iter().enumerate() {
                // if button is relevant, add its press variable to the constraint
                if relevant_idxs.contains(&jolt_idx) {
                    expr += presses[btn_idx];
                }
            }

            // sum of relevant presses == target joltage
            problem.add_constraint(expr.eq(target as f64));
        }

        let solution = problem.solve().unwrap();

        presses
            .iter()
            .map(|v| solution.value(*v).round() as u32)
            .sum()
    }
}

fn part_2(input: &str) -> u32 {
    parse(input).iter().map(|m| m.min_presses_jolts()).sum()
}

Final code

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

3
#[derive(Debug, Clone)]
4
struct Machine {
5
    lights: Vec<bool>,
6
    buttons: Vec<Vec<usize>>,
7
    jolts: Vec<u32>,
8
}
9

10
impl Machine {
11
    fn min_presses_lights(&self) -> usize {
12
        let goal: u32 =
13
            self.lights
14
                .iter()
15
                .enumerate()
16
                .fold(0, |acc, (i, &on)| if on { acc | (1 << i) } else { acc });
17
        let buttons: Vec<u32> = self
18
            .buttons
19
            .iter()
20
            .map(|idxs| idxs.iter().fold(0, |acc, &idx| acc | (1 << idx)))
21
            .collect();
22

23
        // queue of (curr_lights, num_presses)
24
        let mut q = VecDeque::from([(0, 0)]);
25
        let mut seen = HashSet::from([0]);
26

27
        while let Some((lights, presses)) = q.pop_front() {
28
            if lights == goal {
29
                return presses;
30
            }
31
            for button in &buttons {
32
                let next = lights ^ button;
33
                if seen.insert(next) {
34
                    q.push_back((next, presses + 1));
35
                }
36
            }
37
        }
38

39
        0
40
    }
41

42
    fn min_presses_jolts(&self) -> u32 {
43
        use good_lp::*;
44

45
        // create variable per button (number of times it got pressed)
46
        let mut vars = variables!();
47
        let presses: Vec<Variable> = (0..self.buttons.len())
48
            .map(|_| vars.add(variable().min(0).integer()))
49
            .collect();
50

51
        // minimize total presses
52
        let total_presses: Expression = presses.iter().sum();
53
        let mut problem = vars.minimise(total_presses).using(default_solver);
54

55
        // for each jolt counter, sum of relevant presses must equal the target joltage
56
        for (jolt_idx, &target) in self.jolts.iter().enumerate() {
57
            let mut expr = Expression::from(0.0);
58

59
            for (btn_idx, relevant_idxs) in self.buttons.iter().enumerate() {
60
                // if button is relevant, add its press variable to the constraint
61
                if relevant_idxs.contains(&jolt_idx) {
62
                    expr += presses[btn_idx];
63
                }
64
            }
65

66
            // sum of relevant presses == target joltage
67
            problem.add_constraint(expr.eq(target as f64));
68
        }
69

70
        let solution = problem.solve().unwrap();
71

72
        presses
73
            .iter()
74
            .map(|v| solution.value(*v).round() as u32)
75
            .sum()
76
    }
77
}
78

79
fn parse(input: &str) -> Vec<Machine> {
80
    input
81
        .lines()
82
        .map(|line| {
83
            let (lights_str, rest) = line.split_once(' ').unwrap();
84
            let (buttons_str, jolts_str) = rest.rsplit_once(' ').unwrap();
85

86
            let lights = lights_str
87
                .trim_matches(['[', ']'])
88
                .chars()
89
                .map(|c| c == '#')
90
                .collect();
91

92
            let buttons = buttons_str
93
                .split(' ')
94
                .map(|s| {
95
                    s.trim_matches(['(', ')'])
96
                        .split(',')
97
                        .map(|s| s.parse().unwrap())
98
                        .collect()
99
                })
100
                .collect();
101

102
            let jolts = jolts_str
103
                .trim_matches(['{', '}'])
104
                .split(',')
105
                .map(|s| s.parse().unwrap())
106
                .collect();
107

108
            Machine {
109
                lights,
110
                buttons,
111
                jolts,
112
            }
113
        })
114
        .collect()
115
}
116

117
pub fn part_1(input: &str) -> usize {
118
    parse(input).iter().map(|m| m.min_presses_lights()).sum()
119
}
120

121
pub fn part_2(input: &str) -> u32 {
122
    parse(input).iter().map(|m| m.min_presses_jolts_2()).sum()
123
}

Date

Tagged

Part of series

Older post

Newer post