94 lines
2.3 KiB
Elixir
94 lines
2.3 KiB
Elixir
defmodule Aoc2023.Day10 do
|
|
use Aoc2023
|
|
require Integer
|
|
|
|
@connections %{
|
|
?| => [{-1, 0}, {1, 0}],
|
|
?- => [{0, -1}, {0, 1}],
|
|
?L => [{-1, 0}, {0, 1}],
|
|
?J => [{-1, 0}, {0, -1}],
|
|
?7 => [{1, 0}, {0, -1}],
|
|
?F => [{1, 0}, {0, 1}],
|
|
?. => [],
|
|
?S => []
|
|
}
|
|
|
|
defp add_coords({y, x}, {y_, x_}), do: {y + y_, x + x_}
|
|
|
|
defp path(s_conns, conns) do
|
|
loop = fn recur, checked, checking ->
|
|
checked_ = MapSet.union(checked, checking)
|
|
|
|
checking_ =
|
|
checking
|
|
|> Enum.flat_map(&Map.get(conns, &1, []))
|
|
|> MapSet.new()
|
|
|> MapSet.difference(checked_)
|
|
|
|
if MapSet.size(checking_) > 0, do: recur.(recur, checked_, checking_), else: checked_
|
|
end
|
|
|
|
loop.(loop, MapSet.new(), MapSet.new(s_conns))
|
|
end
|
|
|
|
def parse(input) do
|
|
grid =
|
|
input
|
|
|> lines
|
|
|> Enum.map(&String.to_charlist/1)
|
|
|> Enum.with_index()
|
|
|
|
s =
|
|
grid
|
|
|> Enum.find_value(fn {line, y} ->
|
|
x = line |> Enum.find_index(&(&1 == ?S))
|
|
if x, do: {y, x}
|
|
end)
|
|
|
|
conns =
|
|
grid
|
|
|> Enum.flat_map(fn {row, y} ->
|
|
row
|
|
|> Enum.with_index()
|
|
|> Enum.map(fn {c, x} ->
|
|
{
|
|
{y, x},
|
|
Map.get(@connections, c) |> Enum.map(pipe(add_coords({y, x})))
|
|
}
|
|
end)
|
|
end)
|
|
|> Enum.into(%{})
|
|
|
|
s_conns = conns |> Enum.filter(&(s in elem(&1, 1))) |> Enum.map(pipe(elem(0)))
|
|
{s, s_conns, grid, path(s_conns, conns)}
|
|
end
|
|
|
|
def part1({_, _, _, path}) do
|
|
path
|
|
|> MapSet.size()
|
|
|> then(&(&1 / 2))
|
|
|> trunc()
|
|
end
|
|
|
|
def part2({{sy, sx}, s_conns, grid, path}) do
|
|
s_dirs = s_conns |> Enum.map(pipe(add_coords({-sy, -sx}))) |> Enum.sort()
|
|
s_char = @connections |> Enum.find(fn {_, conns} -> Enum.sort(conns) == s_dirs end) |> elem(0)
|
|
grid_ = grid |> list_map_at(sy, pipe(map_nth(0, pipe(List.replace_at(sx, s_char)))))
|
|
|
|
grid_
|
|
|> Stream.map(fn {line, y} ->
|
|
for x <- 0..length(line) - 1, reduce: {false, 0} do
|
|
{within, area} ->
|
|
cond do
|
|
{y, x} in path and Enum.at(line, x) in [?L, ?J, ?|] -> {not within, area}
|
|
{y, x} in path -> {within, area}
|
|
within -> {within, area + 1}
|
|
true -> {within, area}
|
|
end
|
|
end
|
|
|> elem(1)
|
|
end)
|
|
|> Enum.sum()
|
|
end
|
|
end
|