I created a grid struct yesterday for day 10’s challenge and spent a decent amount of my time adding to it to solve this one. Definitely going to have to implement reduce for it if we keep getting more of these.
My solution today feels much more verbose than it probably could be, but it runs in under 100 ms.
require Grid
defmodule Aoc2024.Day12 do
@moduledoc false
def part1(file) do
get_input(file)
|> assign_plots()
|> fence_price1()
end
defp get_input(file) do
File.read!(file)
|> Grid.new(fn v -> v end)
end
defp assign_plots(grid) do
for y <- 0..grid.last_y, x <- 0..grid.last_x do
{x, y}
end
|> Enum.reduce({grid, 0}, fn position, {acc, plot_id} ->
v = Grid.at(acc, position)
if is_integer(v) do
{acc, plot_id}
else
{explore_plot(acc, position, v, plot_id), plot_id + 1}
end
end)
|> Tuple.to_list()
|> List.first()
end
# Walk through the region from the starting point finding all points within the same plot.
# Return an updated grid with all points within the plot updated to have the value of the given id.
defp explore_plot(grid, position, initial, plot_id) do
if is_integer(Grid.at(grid, position)) do
grid
else
# IO.inspect("{#{x},#{y}} #{initial} #{plot_id}")
new = Grid.put(grid, position, plot_id)
new
|> Grid.neighbors(position)
|> then(&Grid.filter(new, &1, fn v -> v == initial end))
|> Enum.reduce(new, fn neighbor, acc ->
explore_plot(acc, neighbor, initial, plot_id)
end)
end
end
defp fence_price1(grid) do
counts = {%{}, %{}}
{areas, perimeters} =
for y <- 0..grid.last_y, x <- 0..grid.last_x do
{x, y}
end
|> Enum.reduce(counts, fn position = {x, y}, {areas, perimeters} ->
plot_id = Grid.at(grid, position)
areas = Map.update(areas, plot_id, 1, &(&1 + 1))
[{1, 0}, {0, 1}, {0, -1}, {-1, 0}]
|> Enum.map(fn {dx, dy} -> {x + dx, y + dy} end)
|> Enum.reduce({areas, perimeters}, fn neighbor, {areas, perimeters} ->
if plot_id == Grid.at(grid, neighbor) do
{areas, perimeters}
else
{areas, Map.update(perimeters, plot_id, 1, &(&1 + 1))}
end
end)
end)
Map.keys(areas)
|> Enum.map(fn plot_id ->
Map.get(areas, plot_id) * Map.get(perimeters, plot_id)
end)
|> Enum.sum()
end
def part2(file) do
get_input(file)
|> assign_plots()
|> fence_price2()
end
defp fence_price2(grid) do
areas = areas(grid)
region_sides = region_sides(grid)
Map.keys(areas)
|> Enum.map(fn plot_id ->
Map.get(areas, plot_id) * Map.get(region_sides, plot_id)
end)
|> Enum.sum()
end
defp areas(grid) do
areas = %{}
for y <- 0..grid.last_y, x <- 0..grid.last_x do
{x, y}
end
|> Enum.reduce(areas, fn position, areas ->
plot_id = Grid.at(grid, position)
# Map.update(areas, plot_id, MapSet.new([position]), &(MapSet.put(&1, position)))
Map.update(areas, plot_id, 1, &(&1 + 1))
end)
end
defp region_sides(grid) do
sides = %{}
for y <- 0..grid.last_y, x <- 0..grid.last_x do
{x, y}
end
|> Enum.reduce(sides, fn position, sides ->
plot_id = Grid.at(grid, position)
fsc = fence_side_cost(grid, position)
Map.update(sides, plot_id, fsc, &(&1 + fsc))
end)
end
defp fence_side_cost(grid, position) do
n = named_neighbors(position)
left_n = named_neighbors(n.left)
above_n = named_neighbors(n.above)
above_below_cost(grid, position, n.above, n.left, left_n.above) +
above_below_cost(grid, position, n.below, n.left, left_n.below) +
left_right_cost(grid, position, n.left, n.above, above_n.left) +
left_right_cost(grid, position, n.right, n.above, above_n.right)
end
defp above_below_cost(grid, pos, ab, left, left_ab) do
if fence_between(grid, pos, ab) and
(fence_between(grid, pos, left) or same_plot(grid, left, left_ab)) do
1
else
0
end
end
defp left_right_cost(grid, pos, lr, above, above_lr) do
if fence_between(grid, pos, lr) and
(fence_between(grid, pos, above) or same_plot(grid, above, above_lr)) do
1
else
0
end
end
defp same_plot(grid, position1, position2) do
Grid.at(grid, position1) == Grid.at(grid, position2)
end
defp fence_between(grid, position1, position2) do
Grid.at(grid, position1) != Grid.at(grid, position2)
end
defp named_neighbors({x, y}) do
%{left: {x - 1, y}, right: {x + 1, y}, above: {x, y - 1}, below: {x, y + 1}}
end
end
