95 lines
2.1 KiB
Elixir
95 lines
2.1 KiB
Elixir
defmodule Day3 do
|
|
defmodule Rect do
|
|
defstruct [:id, :left, :top, :width, :height]
|
|
|
|
def points(nil), do: []
|
|
|
|
def points(rect) do
|
|
xs = rect.left..(rect.left + rect.width - 1)
|
|
|
|
Enum.flat_map(xs, fn x ->
|
|
ys = rect.top..(rect.top + rect.height - 1)
|
|
Enum.map(ys, fn y -> {x, y} end)
|
|
end)
|
|
end
|
|
|
|
def overlap(a, b) do
|
|
overlap_left = max(a.left, b.left)
|
|
overlap_width = max(0, min(a.left + a.width, b.left + b.width) - overlap_left)
|
|
overlap_top = max(a.top, b.top)
|
|
overlap_height = max(0, min(a.top + a.height, b.top + b.height) - overlap_top)
|
|
|
|
case overlap_width * overlap_height do
|
|
0 ->
|
|
nil
|
|
|
|
_ ->
|
|
%Rect{
|
|
left: overlap_left,
|
|
top: overlap_top,
|
|
width: overlap_width,
|
|
height: overlap_height
|
|
}
|
|
end
|
|
end
|
|
end
|
|
|
|
def parse_rect(str) do
|
|
parts = Regex.run(~r/#(\d+) @ (\d+),(\d+): (\d+)x(\d+)/, str)
|
|
|
|
%Rect{
|
|
id: parts |> Enum.at(1) |> String.to_integer(),
|
|
left: parts |> Enum.at(2) |> String.to_integer(),
|
|
top: parts |> Enum.at(3) |> String.to_integer(),
|
|
width: parts |> Enum.at(4) |> String.to_integer(),
|
|
height: parts |> Enum.at(5) |> String.to_integer()
|
|
}
|
|
end
|
|
|
|
def except(list, except) do
|
|
Enum.reject(list, fn el -> el == except end)
|
|
end
|
|
|
|
def overlap_area(rects) do
|
|
rects
|
|
|> Enum.flat_map(fn rect ->
|
|
rects
|
|
|> except(rect)
|
|
|> Enum.map(fn other ->
|
|
Rect.overlap(rect, other)
|
|
end)
|
|
|> Enum.flat_map(&Rect.points/1)
|
|
end)
|
|
|> Enum.uniq()
|
|
|> Enum.count()
|
|
end
|
|
|
|
def exclude_overlapping(rects) do
|
|
rects
|
|
|> Enum.reject(fn rect ->
|
|
rects
|
|
|> except(rect)
|
|
|> Enum.any?(fn other ->
|
|
Rect.overlap(rect, other) != nil
|
|
end)
|
|
end)
|
|
end
|
|
|
|
def parse_input() do
|
|
File.read!("lib/day3/input.txt")
|
|
|> String.split("\n", trim: true)
|
|
end
|
|
|
|
def part1() do
|
|
parse_input()
|
|
|> Enum.map(&parse_rect/1)
|
|
|> overlap_area()
|
|
end
|
|
|
|
def part2() do
|
|
parse_input()
|
|
|> Enum.map(&parse_rect/1)
|
|
|> exclude_overlapping()
|
|
end
|
|
end
|