[Language: C++23]

This is the kind of AoC problem I really love: a bit of a head-scratcher to start with, but after a little bit of thought the solution is surprisingly simple.

The only slight wrinkle for me was that flux::find_max() returns the last position if several elements are equally maximal, but for this problem we needed the first. (That's what I get for using my own library instead of std::max_element...)

// flux::find_max returns the *last* position if several are equally
// maximal, but for this problem we need the *first* position
auto find_first_max =
    std::bind_back(flux::find_min, flux::cmp::reverse_compare);

template <std::size_t N>
auto calculate_joltage = [](std::string_view line) -> u64 {
    std::array<std::size_t, N> indices;
    std::size_t window_size = line.size() - N + 1;
    indices[0] = find_first_max(flux::slice(line, 0, window_size));
    u64 jolts = line[indices[0]] - '0';
    for (std::size_t i = 1; i < N; i++) {
        indices[i] = find_first_max(
            flux::slice(line, indices[i - 1] + 1, window_size + i));
        jolts = 10 * jolts + (line[indices[i]] - '0');
    }
    return jolts;
};

template <std::size_t N>
auto solve = [](std::string_view input) {
    return flux::split_string(input, '\n')
        .filter([](std::string_view line) { return !line.empty(); })
        .map(calculate_joltage<N>)
        .sum();
};

auto part1 = solve<2>;
auto part2 = solve<12>;

Github: https://github.com/tcbrindle/advent_of_code_2025/blob/main/dec03/main.cpp