 -> std::pair<int, u64> {
std::flat_map<int, u64> beam_counts, next_beam_counts;
beam_counts[flux::find(grid.data, 'S')] = 1;
int split_count = 0;
for (int row : flux::iota(1, grid.height)) {
for (auto [col, count] : beam_counts) {
if (grid[col, row] == '^') {
next_beam_counts[col - 1] += count;
next_beam_counts[col + 1] += count;
++split_count;
} else {
next_beam_counts[col] += count;
}
}
std::swap(beam_counts, next_beam_counts);
next_beam_counts.clear();
}
return {split_count, flux::sum(beam_counts.values())};
};](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:gqt2ib3qygcc3bakxhbcr5cq/bafkreid2bhmagyq7eatls6sqzfcppidmxz3e7tpuyd24l7v2ksg6eq7phq)
auto solve = [](grid2d const& grid) -> std::pair<int, u64> { std::flat_map<int, u64> beam_counts, next_beam_counts; beam_counts[flux::find(grid.data, 'S')] = 1; int split_count = 0; for (int row : flux::iota(1, grid.height)) { for (auto [col, count] : beam_counts) { if (grid[col, row] == '^') { next_beam_counts[col - 1] += count; next_beam_counts[col + 1] += count; ++split_count; } else { next_beam_counts[col] += count; } } std::swap(beam_counts, next_beam_counts); next_beam_counts.clear(); } return {split_count, flux::sum(beam_counts.values())}; };
Nothing particularly fancy for today's #AdventOfCode, but it did give me an excuse to use C++23's std::flat_map for the first time
Github: github.com/tcbrindle/ad...
 {
return grid.coordinates()
.filter([&](coord pos) { return grid[pos] == '@'; })
.count_if([&](coord pos) { return can_access(grid, pos); });
};
auto part2 = [](grid2d grid) {
int total_removed = 0;
while (true) {
int removed = 0;
grid.coordinates()
.filter([&](coord pos) {
return grid[pos] == '@' && can_access(grid, pos);
})
.for_each([&](coord pos) {
grid[pos] = '.';
++removed;
});
total_removed += removed;
if (removed == 0) { return total_removed; }
}
};](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:gqt2ib3qygcc3bakxhbcr5cq/bafkreibfvi5lnjnnwdejzboihtryqln77ss6cb5maqsfol3m5rurusdnju)
 -> 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 const part1 = solve<2>;
auto const part2 = solve<12>;](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:gqt2ib3qygcc3bakxhbcr5cq/bafkreibi2kdfyq4gkrt6qoy4ofxamk72cqwhrbgdld22cne5pswb5mzdpe)
 -> bool {
auto const str = to_string(id);
auto mid = str.size() / 2;
return flux::equal(flux::ref(str).take(mid), flux::ref(str).drop(mid));
};
auto is_invalid_id_p2 = [](u64 id) -> bool {
auto const str = to_string(id);
return flux::iota(1uz, 1 + str.size() / 2)
.filter([&](auto sz) { return str.size() % sz == 0; })
.map([&](auto sz) { return flux::ref(str).chunk(sz); })
.any([](flux::multipass_sequence auto chunks) {
auto first = chunks.front().value();
return std::move(chunks).drop(1).all(
[&](auto chunk) { return flux::equal(chunk, first); });
});
};
template <auto TestFn>
auto test_ranges = [](std::vector<id_range> const& input) -> u64 {
return flux::ref(input)
.map([](id_range rng) { return flux::iota(rng.from, rng.to + 1); })
.flatten()
.filter(TestFn)
.sum();
};
auto part1 = test_ranges<is_invalid_id_p1>;
auto part2 = test_ranges<is_invalid_id_p2>;](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:gqt2ib3qygcc3bakxhbcr5cq/bafkreifhy4xbvbx74syrx332ltna3qwsy2m4rydjgynx4rv3mcvocmgv7q)
{
return self.data[pos.y * Size + pos.x];
}
};
template <int Size, std::size_t N>
auto part1(std::span<position const> bytes) -> int {
grid_t<Size> grid{};
flux::for_each(bytes.first<N>(),
[&](position const& pos) { grid[pos] = true; });
return dijkstra(graph_t{grid}, {0, 0}).at(grid.target);
}
template <int Size, std::size_t Skip>
auto part2(std::span<position const> bytes) -> position {
auto idx = *std::ranges::partition_point(
std::views::iota(Skip, bytes.size()), [&](std::size_t n) {
grid_t<Size> grid{};
flux::for_each(bytes.first(n + 1),
[&](position const& pos) { grid[pos] = true; });
return dijkstra(graph_t{grid}, {0, 0}).contains(grid.target);
});
return bytes[idx];
}](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:gqt2ib3qygcc3bakxhbcr5cq/bafkreicdo2lfhhgl54mxbnzgcq4jwwrfvfry47zlxxd35cqe7radrb2bzu)
 -> std::vector<robot> {
constexpr auto& regex = R"(p=(-?\d+),(-?\d+) v=(-?\d+),(-?\d+)\n?)";
return flux::map(ctre::tokenize<regex>(input),
[](auto result) {
auto [_, px, py, vx, vy] = result;
return robot{.pos = {px.to_number(), py.to_number()},
.vel = {vx.to_number(), vy.to_number()}};
})
.to<std::vector>();
};
template <vec2 Bounds>
auto const part1 = [](std::vector<robot> robots) -> int64_t {
// Move robots
for (auto& [pos, vel] : robots) {
pos += 100 * (vel + Bounds);
pos.x %= Bounds.x;
pos.y %= Bounds.y;
}
// Calculate safety factor
std::array<int64_t, 4> quadrants{};
for (auto const& [pos, _] : robots) {
if (pos.x < Bounds.x / 2) {
if (pos.y < Bounds.y / 2) {
++quadrants[0];
} else if (pos.y > Bounds.y / 2) {
++quadrants[1];
}
} else if (pos.x > Bounds.x / 2) {
if (pos.y < Bounds.y / 2) {
++quadrants[2];
} else if (pos.y > Bounds.y / 2) {
++quadrants[3];
}
}
}
return flux::product(quadrants);
};](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:gqt2ib3qygcc3bakxhbcr5cq/bafkreie7ugjyzxyessiw2s4fjtmkbc7tkegm3fmooqtjkkffg5gzohca6a)
![struct game_info {
vec2 a;
vec2 b;
vec2 prize;
};
auto solve(game_info const& game) -> std::optional<i64>
{
auto [a, b, prize] = game;
i64 i = b.y * prize.x - b.x * prize.y;
i64 j = -a.y * prize.x + a.x * prize.y;
i64 det = (a.x * b.y) - (a.y * b.x);
if (det == 0 || i % det != 0 || j % det != 0) {
return std::nullopt;
} else {
return 3 * i / det + j / det;
}
}
auto part1(std::vector<game_info> const& games) -> i64
{
return flux::ref(games).map(solve).filter_deref().sum();
}
auto part2(std::vector<game_info> const& games) -> i64
{
return flux::ref(games)
.map([](game_info g) {
g.prize += vec2{10000000000000, 10000000000000};
return solve(g);
})
.filter_deref()
.sum();
}](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:gqt2ib3qygcc3bakxhbcr5cq/bafkreifadiebu5ffdkqnt4y6uo6nrdq5cs7m5x2ilrru35q5v6tn7mbf2e)
 -> u64 {
stones_map next;
for (auto _ : flux::ints(0, N)) {
for (auto [val, count] : stones) {
if (val == 0) {
next[1] += count;
} else if (auto opt = split_digits(val)) {
next[opt->first] += count;
next[opt->second] += count;
} else {
next[val * 2024] += count;
}
}
std::swap(stones, next);
next.clear();
}
return flux::sum(stones | std::views::values);
};
auto const part1 = blink<25>;
auto const part2 = blink<75>;](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:gqt2ib3qygcc3bakxhbcr5cq/bafkreifyndus3hqvwv626g34qnfiuefrid7sindmhkvlzcpv4jareyfsnm)
 -> void {
char value = grid[here];
if (value == '9') {
goals.push_back(here);
} else {
get_neighbours(here)
.filter([&](position p) {
return grid.is_in_bounds(p) &&
(grid[p] == value + 1);
})
.for_each(self);
}
}(start);
flux::sort(goals);
int score = flux::ref(goals).dedup().count();
return {.score = score, .rating = int(goals.size())};
};
auto walk_all(std::string_view input) -> trail_info
{
auto grid = parse_input(input);
return grid.positions()
.filter([&](auto pos) { return grid[pos] == '0'; })
.map(std::bind_front(walk_trail, grid))
.fold([](auto sum, auto info) {
sum.score += info.score;
sum.rating += info.rating;
return sum;
},
trail_info{});
};](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:gqt2ib3qygcc3bakxhbcr5cq/bafkreih4vdzoeeq7vkvn2a3qh4oe4khhgsiogt57thrffttg7bjdhzddli)