Flashes
Home
Search
Notifications
Sign in
Post
Tristan Brindle
@tristanbrindle.com
225
Followers
·
93
Following
 -> 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)
 {
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)
 -> u64 {
return flux::from(ctre::search_all<"(\\d+)-(\\d+)">(input))
.map([](auto match) {
auto [_, lo, hi] = match;
return flux::iota(aoc::parse<u64>(lo), 1 + aoc::parse<u64>(hi));
})
.flatten()
.filter([](u64 value) { return ctre::match<Regex>(to_string(value)); })
.sum();
};
auto part1 = test_ranges<"(\\d+)\\1">;
auto part2 = test_ranges<"(\\d+)\\1+">;](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:gqt2ib3qygcc3bakxhbcr5cq/bafkreid6lf4nlihha4a3zebg7cx6zjcighrzrzd4hb2ffbikmoeffoxcqy)
 -> 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)
 { return rules.contains(l, r); };
return flux::ref(updates)
.filter([&](update_t const& u) { return std::ranges::is_sorted(u, cmp); })
.map([](update_t const& u) { return u.at(u.size() / 2); })
.sum();
};
auto part2(rules_t const& rules, std::vector<update_t> const& updates) -> int
{
auto cmp = [&](int l, int r) { return rules.contains({l, r}); };
return flux::ref(updates)
.filter([&](update_t const& u) { return !std::ranges::is_sorted(u, cmp); })
.map([&](update_t u) {
std::ranges::sort(u, cmp);
return u.at(u.size() / 2);
})
.sum();
};](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:gqt2ib3qygcc3bakxhbcr5cq/bafkreif3qzno46poq63dwgvwpntdp5zfrg4w5a3ab3yzspkz4ixfzoqon4)
![// helper function which returns a sequence that lazily generates
// the 8 length-3 strings originating at [x, y]
auto neighbours = [](grid2d const& grid, i64 x, i64 y) {
return flux::cartesian_power<2>(flux::ints(-1, 2))
.filter(flux::unpack([](i64 i, i64 j) { return !(i == 0 && j == 0); }))
.map(flux::unpack([&grid, x, y](i64 i, i64 j) {
return std::string{grid[x + i, y + j],
grid[x + 2 * i, y + 2 * j],
grid[x + 3 * i, y + 3 * j]};
}));
};
// for each grid position, if it contains an 'X' then find the 8 strings
// surrounding it and count how many of those match 'MAS'
auto part1 = [](grid2d const& grid) -> i64 {
return flux::cartesian_product(flux::ints(0, grid.height),
flux::ints(0, grid.width))
.filter(flux::unpack([&](i64 x, i64 y) { return grid[x, y] == 'X'; }))
.map(flux::unpack([&](i64 x, i64 y) { return neighbours(grid, x, y); }))
.flatten()
.count_if(flux::pred::eq("MAS"sv));
};
// for each grid position, look at a 3x3 window and check whether
// the leading and back diagonals both match either 'MAS' or 'SAM'
auto part2 = [](grid2d const& grid) -> i64 {
return flux::cartesian_product(flux::ints(0, grid.height - 2),
flux::ints(0, grid.width - 2))
.count_if(flux::unpack([&grid](i64 x, i64 y) {
std::string lead{grid[x, y], grid[x+1, y+1], grid[x+2, y+2]};
std::string back{grid[x+2, y], grid[x+1, y+1], grid[x, y+2]};
return (lead == "MAS" || lead == "SAM")
&& (back == "MAS" || back == "SAM");
}));
};](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:gqt2ib3qygcc3bakxhbcr5cq/bafkreihjs5bztylrmdfanhvlyeoot7l5efy3wkfvk4qfp2us776b2bexgu)
 -> int {
constexpr auto& regex = R"(mul\((\d{1,3}),(\d{1,3})\))";
return flux::from_range(ctre::search_all<regex>(input))
.map([](auto result) {
auto [_, a, b] = result;
return a.to_number() * b.to_number();
})
.sum();
};
auto part2 = [](std::string_view input) -> int {
return flux::split_string(input, "do()")
.map([](std::string_view chunk) {
return flux::split_string(chunk, "don't()")
.front()
.map(part1)
.value();
})
.sum();
};](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:gqt2ib3qygcc3bakxhbcr5cq/bafkreibyiq6rpmlx3kgnd6j22j5rdihy4bj7tts7intbn6ffxw5prijg3m)
 -> bool {
return (is_sorted(seq, std::less{}) || is_sorted(seq, std::greater{}))
&& flux::ref(seq).pairwise_map(abs_diff).all(flux::pred::geq(1)
&& flux::pred::leq(3));
};
// Returns an adapted sequence which skips the element at index n
auto skip_n = [](std::vector<int> const& vec, flux::index_t n) {
return flux::ints(0, vec.size())
.filter(flux::pred::neq(n))
.map([&vec](auto idx) -> decltype(auto) { return vec.at(idx); });
};
auto part1 = [](std::vector<std::vector<int>> const& vec) -> int {
return flux::count_if(vec, is_safe);
};
auto part2 = [](std::vector<std::vector<int>> const& vec) -> int {
return flux::count_if(vec, [](auto const& report) -> bool {
return is_safe(report)
|| flux::ints(0, report.size())
.map([&report](int i) { return skip_n(report, i); })
.any(is_safe);
});
};](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:gqt2ib3qygcc3bakxhbcr5cq/bafkreih23tvasbapay35vuwz6ursgdrylyxqpapqtwjhjqpxhnhpkhxqhq)
 { return sum + abs(a - b); }, 0, vec1, vec2);
};
auto part2(std::vector<i64> const& vec1, std::vector<i64> const& vec2) -> i64
{
return flux::ref(vec1)
.map([&vec2](i64 elem) { return elem * flux::count_eq(vec2, elem); })
.sum();
};](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:gqt2ib3qygcc3bakxhbcr5cq/bafkreiefksk6wmz4e6fpuiw2hjoq5vmg7swh2dunpjfoktzzxa35ttnd5y)