111 lines
2.1 KiB
Elixir
111 lines
2.1 KiB
Elixir
defmodule Aoc2023.Day3 do
|
|
use Aoc2023
|
|
|
|
@symbols [
|
|
?$,
|
|
?%,
|
|
?&,
|
|
?*,
|
|
?+,
|
|
?-,
|
|
?/,
|
|
?=,
|
|
?@,
|
|
?#
|
|
]
|
|
|
|
defp adjacents({y, x, len}, grid) do
|
|
[
|
|
{y, x - 1},
|
|
{y, x + len}
|
|
| for(y <- [y - 1, y + 1], x <- (x - 1)..(x + len), do: {y, x})
|
|
]
|
|
|> Enum.filter(fn {y, x} ->
|
|
0 <= y and y < length(grid) and 0 <= x and x < length(Enum.at(grid, y))
|
|
end)
|
|
end
|
|
|
|
defp adjacents({y, x}, grid), do: adjacents({y, x, 1}, grid)
|
|
|
|
defp get({y, x}, grid) do
|
|
grid |> Enum.at(y) |> Enum.at(x)
|
|
end
|
|
|
|
defp get({y, x, len}, grid) do
|
|
x..(x + len - 1) |> Enum.map(&get({y, &1}, grid))
|
|
end
|
|
|
|
defp contains({y, x}, numbers) do
|
|
numbers
|
|
|> Enum.filter(fn {ny, nx, nlen} -> ny == y and nx <= x and x < nx + nlen end)
|
|
end
|
|
|
|
defp number(num, grid) do
|
|
num
|
|
|> get(grid)
|
|
|> Enum.map(&(&1 - ?0))
|
|
|> Integer.undigits()
|
|
end
|
|
|
|
def parse(input) do
|
|
grid =
|
|
input
|
|
|> String.split("\n")
|
|
|> Enum.map(&String.to_charlist/1)
|
|
|
|
{
|
|
grid,
|
|
grid
|
|
|> Enum.with_index()
|
|
|> Enum.flat_map(fn {row, y} ->
|
|
row
|
|
|> runs(&(?0 <= &1 && &1 <= ?9))
|
|
|> Enum.map(fn {x, len} -> {y, x, len} end)
|
|
end)
|
|
}
|
|
end
|
|
|
|
def part1({grid, numbers}) do
|
|
numbers
|
|
|> Enum.map(id &&& adjacents(grid))
|
|
|> Enum.filter(
|
|
pipe(
|
|
elem(1)
|
|
|> Enum.any?(&(get(&1, grid) in @symbols))
|
|
)
|
|
)
|
|
|> Enum.map(
|
|
pipe(
|
|
elem(0)
|
|
|> number(grid)
|
|
)
|
|
)
|
|
|> Enum.sum()
|
|
end
|
|
|
|
def part2({grid, numbers}) do
|
|
grid
|
|
|> Enum.with_index()
|
|
|> Enum.flat_map(fn {row, y} ->
|
|
row
|
|
|> Enum.with_index()
|
|
|> Enum.filter(&(elem(&1, 0) == ?*))
|
|
|> Enum.map(&{y, elem(&1, 1)})
|
|
|> Enum.map(id &&& adjacents(grid))
|
|
|> Enum.map(pipe(
|
|
elem(1)
|
|
|> Enum.flat_map(pipe(contains(numbers)))
|
|
|> Enum.uniq()
|
|
))
|
|
|> Enum.filter(pipe(
|
|
length()
|
|
|> then(&(&1 == 2)))
|
|
)
|
|
|> Enum.map(pipe(
|
|
Enum.map(pipe(number(grid))) |> Enum.product
|
|
))
|
|
end)
|
|
|> Enum.sum
|
|
end
|
|
end
|