There is a decent amount of puzzles that require to expand the grid, or to take only a sub part of it like today.
This is my first time doing AOC so that’s a great tip.
What really help me get unstuck today was learning how to implement the Inspect protocol for debugging. Being able to easily see the example grid step by step is so beneficial. Loving how easy it is to implement things like that in Elixir with minimal code.
finally managed to understand the convex and concave solution and extracted it from your solution into my own. I have never done stuff like this, so this was totally new to me.
https://github.com/jarlah/advent_of_code/blob/master/lib/2024/day_12/Part1%262.ex#L38
as you can see i just mapped my list of positions into a map, to adjust for the count_corners function.
but you had x and y flipped though 
i flipped them back 
PS! What would be nice though .. is if anyone had some learning material or visualization for convex and concave checks in a grid.
I put the puzzles down for a bit yesterday and decided to get back to it this morning.
Here’s my pass at part 2 after reading up a bit here:
#!/usr/bin/env elixir
defmodule Day12.Part2 do
defp parse(str) do
[row | _rows] =
rows =
str
|> String.split("\n", trim: true)
|> Enum.map(&to_charlist/1)
height = Enum.count(rows)
length = Enum.count(row)
graph = :digraph.new([:acyclic])
for y <- 0..(height - 1) do
for x <- 0..(length - 1) do
value = rows |> Enum.at(y) |> Enum.at(x)
:digraph.add_vertex(graph, {x, y}, value)
[{x + 1, y}, {x - 1, y}, {x, y + 1}, {x, y - 1}]
|> Enum.filter(fn {n_x, n_y} = neighbor ->
on_board?(neighbor, height, length) and rows |> Enum.at(n_y) |> Enum.at(n_x) == value
end)
|> Enum.each(fn neighbor -> :digraph.add_edge(graph, {x, y}, neighbor) end)
end
end
:digraph_utils.components(graph)
end
defp on_board?({x, y}, height, length) when x < 0 or x >= length or y < 0 or y >= height,
do: false
defp on_board?(_pair, _height, _length), do: true
defp area(contiguous_region) do
contiguous_region |> Enum.count()
end
defp corner?({side_a, side_b, diagonal}, contiguous_region) do
sides = [side_a, side_b]
convex? =
sides
|> Enum.all?(&(not MapSet.member?(contiguous_region, &1)))
concave? =
sides
|> Enum.all?(&MapSet.member?(contiguous_region, &1)) and
not MapSet.member?(contiguous_region, diagonal)
convex? or concave?
end
defp sides({x, y} = _point, %MapSet{} = contiguous_region) do
right = {x + 1, y}
left = {x - 1, y}
below = {x, y + 1}
above = {x, y - 1}
above_left = {x - 1, y - 1}
above_right = {x + 1, y - 1}
below_left = {x - 1, y + 1}
below_right = {x + 1, y + 1}
[
{above, left, above_left},
{above, right, above_right},
{below, right, below_right},
{below, left, below_left}
]
|> Enum.map(fn triple ->
if corner?(triple, contiguous_region), do: 1, else: 0
end)
|> Enum.sum()
end
defp sides(contiguous_region) do
contiguous_region
|> Enum.map(&sides(&1, contiguous_region))
|> Enum.sum()
end
defp fence_cost([point | _points] = contiguous_region) when is_tuple(point) do
area = area(contiguous_region)
sides = sides(MapSet.new(contiguous_region))
area * sides
end
defp fence_cost([region | _regions] = contiguous_regions) when is_list(region) do
contiguous_regions
|> Enum.map(&fence_cost(&1))
|> Enum.sum()
end
def solve() do
File.read!("lib/advent_of_code/year/2024/day/12/input.txt")
|> parse()
|> fence_cost()
|> IO.puts()
end
end
Day12.Part2.solve()
I had figured out the equality of sides to corners, but went in totally the wrong direction for calculating them at first. I may have also read something a while back about corner checking- felt like it rang a bell once I grasped it.
@Flo0807 is this correct counting with convex and concave ?
A A A A
B B C2 D
B B C2 C2
E E E C2
the top c (2,1) has A+B convex and A+D as convex, so 2
the next c (2,2) has B+E convex and D concave, so 2
the top right c (3,2) has E concave and D+nil convex, so 2
the bottom right c (3,3) has E+nil convex and nil+nil convex, so 2
this equals 8?
but the big question is, where do people get this info from? where was it learned ?
For part 2 I implemented a neat maze walking algorithm. Unfortunately, it only counted the outer fences and not fences around enclosed regions. My attempts to handle the enclosed regions didn’t produce the correct answer.
I went back to the drawing board and ended up with this solution:
https://github.com/bjorng/advent-of-code/blob/main/2024/day12/lib/day12.ex
anyway i asked perplexity
https://www.perplexity.ai/search/i-have-recently-learned-about-LLX8S.QhQkuqPO1FoMe2RQ
Im very stubborn on not letting such knowledge pass me by 
the question is both showing that i now fully understand it, its corner counting. And perplexity sheds some light on the background of the theory
A healthy combination of OCD and perseverance lead to me to the final refactor: https://github.com/jarlah/advent_of_code/blob/master/lib/2024/day_12/Part1_2.ex#L113 (next up figure out what the others did, if it was not corner counting)
im now trying to dig into the alternative approaches to convex/concave corner counting and your part2 cost calculation seems a good candidate. Or maybe its hiding the same convex/concave in the code ?
for ex this
sides = region
|> Enum.flat_map(fn plot ->
plot
|> adjacent_squares
|> Enum.filter(&fence?(grid, type, &1))
|> Enum.map(fn square ->
diff = sub(plot, square)
axis = if elem(diff, 1) === 0, do: 0, else: 1
other_axis = rem(axis + 1, 2)
{{diff, elem(plot, axis)}, elem(plot, other_axis)}
end)
end)
it goes through all adjacent squares and subtracts the square (x,y) from the plot (x,y) to get a diff (x, y). Then it sets axis variable to 0 if y from diff is 0, else 1. Then it sets other_axis variable to the remainder of dividing axis (0 or 1) + 1 by 2, which can result in 2 or 1. Then end result is {{diff, elem(plot, 0 or 1)}, elem(plot, 1 or 2)} which is basically either {{diff, x}, x} or {{diff, y}, x}. Then we need to find out what this means. it returns which axis is … different? EDIT: my explanation here might be wrong, it just shows how my mind is trying to read the code 
The counting looks good!
but the big question is, where do people get this info from? where was it learned ?
Like I said, I got this vector counting from a reddit post. I guess it’s the kind of math you learn when you dive into grids, 2D spaces and geometry.
ok im guess im going down the long road. If i cant solve it i find someone who has and dissects it to its fine grained atoms
If you struggle with corner counting I suggest to look at my solution (1st post in thread). It thinks it’s straightforward to implement.
Here is the additional code not shared from the Grid module:
def cardinal4(xy) do
[
translate(xy, :n),
translate(xy, :s),
translate(xy, :w),
translate(xy, :e)
]
end
def translate(xy, direction, n \\ 1)
def translate({x, y}, :n, n), do: {x, y - n}
def translate({x, y}, :s, n), do: {x, y + n}
def translate({x, y}, :w, n), do: {x - n, y}
def translate({x, y}, :e, n), do: {x + n, y}