3 Likes
Not the most efficient way to do it (especially part 2) but it takes like 1ms to run anyway so it literally doesn’t matter 
Now back to doing previous year puzzles that I never completed…
I used Enum.dedup/1 instead of Enum.uniq/1 when attempting to solve part 1. This mistake hid another bug, and so I got the correct result for the example but not for my input.
The following solution is refactored to share most of the code for the solution:
1 Like
#!/usr/bin/env elixir
# AoC 2024. day 8.
###########################################################
# Setup
{coords2antennas, nrows, ncols} = File.stream!("../day08.txt")
|> Stream.with_index(1)
|> Enum.reduce({%{}, 0, 0}, fn {line, row}, {map, nrows, ncols} ->
line
|> String.trim_trailing()
|> String.to_charlist()
|> Enum.with_index(1)
|> Enum.reduce({map, nrows, ncols}, fn {c, col}, {map, nrows, ncols} ->
map = (if c != ?., do: Map.put(map, {row,col}, c), else: map)
{map, max(nrows, row), max(ncols, col)}
end)
end)
defmodule M do
# values become keys and vice-versa. values are stored in a list.
def inside_out(map) do
map |> Enum.reduce(%{}, fn {k,v}, res ->
Map.update(res, v, [k], fn lst -> [k|lst] end)
end)
end
def offset({r1,c1}, {r2,c2}), do: {r2-r1,c2-c1}
def add({r,c},{ro,co}), do: {r+ro,c+co}
def sub({r,c},{ro,co}), do: {r-ro,c-co}
def inside({r,c}, nrows, ncols), do: r >= 1 && r <= nrows && c >= 1 && c <= ncols
def pairs([]), do: []
def pairs([x | rest]), do: Enum.map(rest, fn y -> {x,y} end) ++ pairs(rest)
end
###########################################################
# Part 1
coords2antennas
|> M.inside_out()
|> Enum.reduce(MapSet.new(), fn {_antenna, coords}, set ->
pairs = M.pairs(coords)
Enum.reduce(pairs, set, fn {coord1, coord2}, set ->
offset = M.offset(coord1, coord2)
set
|> then(fn set ->
anti = M.sub(coord1, offset)
if M.inside(anti, nrows, ncols), do: MapSet.put(set, anti), else: set
end)
|> then(fn set ->
anti = M.add(coord2, offset)
if M.inside(anti, nrows, ncols), do: MapSet.put(set, anti), else: set
end)
end)
end)
|> tap(fn set -> IO.puts("Part 1. Number of antinodes: #{MapSet.size(set)}") end)
###########################################################
# Part 2
coords2antennas
|> M.inside_out()
|> Enum.reduce(MapSet.new(), fn {_antenna, coords}, set ->
pairs = M.pairs(coords)
Enum.reduce(pairs, set, fn {coord1, coord2}, set ->
offset = M.offset(coord1, coord2)
set = Stream.unfold(coord1, fn coord ->
anti = M.sub(coord, offset)
if M.inside(anti, nrows, ncols), do: {anti, anti}
end)
|> Enum.reduce(set, fn anti, set -> MapSet.put(set, anti) end)
Stream.unfold(coord2, fn coord ->
anti = M.add(coord, offset)
if M.inside(anti, nrows, ncols), do: {anti, anti}
end)
|> Enum.reduce(set, fn anti, set -> MapSet.put(set, anti) end)
|> MapSet.put(coord1)
|> MapSet.put(coord2)
end)
end)
|> tap(fn set -> IO.puts("Part 2. Number of antinodes: #{MapSet.size(set)}") end)
Fun day! Finally less bruteforce thinking!
Both solutions were pretty fast to run:
===== YEAR 2024 DAY 8 PART 1 =====
Result:
Took: 5ms
===== YEAR 2024 DAY 8 PART 2 =====
Result:
Took: 2ms
Solution (still working to generalize it):
defmodule AOC.Y2024.Day8 do
@moduledoc false
use AOC.Solution
@impl true
def load_data() do
Data.load_day_as_grid(2024, 8)
|> then(fn {grid, m, n} ->
antennas =
grid
|> Enum.filter(fn {_, v} -> v != "." end)
|> Enum.group_by(fn {_, v} -> v end, fn {k, _} -> k end)
{antennas, m, n}
end)
end
@impl true
def part_one({antennas, m, n}) do
solve(antennas, m, n, &find_antinodes/3)
end
@impl true
def part_two({antennas, m, n}) do
solve(antennas, m, n, &find_antinodes2/3)
end
defp solve(antennas, m, n, func) do
antennas
|> Enum.flat_map(fn {_, coords} ->
func.(coords, m, n)
end)
|> Enum.uniq()
|> Enum.count()
end
defp find_antinodes(coords, m, n) do
coords
|> Enum.with_index(1)
|> Enum.flat_map(fn {coord, i} ->
coords |> Enum.slice(i..-1//1) |> Enum.map(fn other -> {coord, other} end)
end)
|> Enum.flat_map(fn {{a, b}, {c, d}} ->
da = abs(a - c)
db = abs(b - d)
da_sign = div(a - c, abs(a - c))
db_sign = div(b - d, abs(b - d))
nx = {a + da * da_sign, b + db * db_sign}
ny = {c + da * -da_sign, d + db * -db_sign}
[nx, ny]
end)
|> Enum.filter(fn {a, b} ->
a in 0..(m - 1) and b in 0..(n - 1)
end)
end
defp find_antinodes2(coords, m, n) do
coords
|> Enum.with_index(1)
|> Enum.flat_map(fn {coord, i} ->
coords |> Enum.slice(i..-1//1) |> Enum.map(fn other -> {coord, other} end)
end)
|> Enum.flat_map(fn {x, y} ->
inf_antinodes(x, y, m, n)
end)
end
defp inf_antinodes({a, b}, {c, d}, m, n) do
da = abs(a - c)
db = abs(b - d)
da_sign = div(a - c, abs(a - c))
db_sign = div(b - d, abs(b - d))
Stream.iterate({a, b}, fn {x, y} ->
{x + da * da_sign, y + db * db_sign}
end)
|> Stream.take_while(fn {x, y} -> x in 0..(m - 1) and y in 0..(n - 1) end)
|> Stream.concat(
Stream.iterate({c, d}, fn {x, y} ->
{x + da * -da_sign, y + db * -db_sign}
end)
|> Stream.take_while(fn {x, y} -> x in 0..(m - 1) and y in 0..(n - 1) end)
)
|> Enum.to_list()
|> Enum.uniq()
end
end
I struggled way more than expected with my x and y calculations 
Part 1
defmodule Advent.Y2024.Day08.Part1 do
@grid_size 49
def run(puzzle) do
puzzle
|> parse()
|> find_antinodes(&antinodes/2)
|> Enum.count()
end
def parse(puzzle) do
for {line, y} <- puzzle |> String.split("\n") |> Enum.with_index(), reduce: %{} do
acc ->
for {c, x} <- line |> String.graphemes() |> Enum.with_index(), c != ".", reduce: acc do
acc -> Map.update(acc, c, [{x, y}], fn pos -> [{x, y} | pos] end)
end
end
end
def find_antinodes(g, fun) do
for {_, pos} <- g, a1 <- pos, a2 <- pos, a1 != a2, n <- fun.(a1, a2), reduce: MapSet.new() do
nodes -> MapSet.put(nodes, n)
end
end
defp antinodes({x1, y1}, {x2, y2}) do
dx = abs(x1 - x2)
dy = abs(y1 - y2)
Enum.filter(
[
{if(x1 > x2, do: x1 + dx, else: x1 - dx), if(y1 > y2, do: y1 + dy, else: y1 - dy)},
{if(x2 > x1, do: x2 + dx, else: x2 - dx), if(y2 > y1, do: y2 + dy, else: y2 - dy)}
],
fn {x, y} -> x in 0..@grid_size and y in 0..@grid_size end
)
end
end
Part 2
defmodule Advent.Y2024.Day08.Part2 do
@grid_size 49
alias Advent.Y2024.Day08.Part1
def run(puzzle) do
puzzle
|> Part1.parse()
|> Part1.find_antinodes(&antinodes/2)
|> Enum.count()
end
defp antinodes({x1, y1}, {x2, y2}) do
dx = abs(x1 - x2)
dy = abs(y1 - y2)
[{x1, y1}, {x2, y2}] ++
in_direction({x1, y1}, {if(x1 > x2, do: dx, else: -dx), if(y1 > y2, do: dy, else: -dy)}) ++
in_direction({x2, y2}, {if(x2 > x1, do: dx, else: -dx), if(y2 > y1, do: dy, else: -dy)})
end
defp in_direction({x, y}, {dx, dy}, acc \\ []) do
{nx, ny} = {x + dx, y + dy}
if nx in 0..@grid_size and ny in 0..@grid_size do
in_direction({nx, ny}, {dx, dy}, [{nx, ny} | acc])
else
acc
end
end
end
Pretty tame after Friday’s loop detection, I was expecting worse for Sunday (although I took a break yesterday so I’m not sure how that was).
Each part completes in under a millisecond.
def calc_resonant_harmonics({{x_a, y_a}, {x_b, y_b}}, max_x, max_y) do
dx = x_a - x_b
dy = y_a - y_b
[{x_a, y_a}, {x_b, y_b}] ++
resonate(x_a, y_a, dx, dy, max_x, max_y) ++
resonate(x_b, y_b, dx * -1, dy * -1, max_x, max_y)
end
def resonate(x, y, dx, dy, max_x, max_y, multiplier \\ 1) do
next_x = x + dx * multiplier
next_y = y + dy * multiplier
if next_x < 0 or next_x >= max_x or next_y < 0 or next_y >= max_y do
[]
else
[{next_x, next_y} | resonate(x, y, dx, dy, max_x, max_y, multiplier + 1)]
end
end
1 Like
Sundays are supposed to be harder but today was quite easy:)
defmodule AdventOfCode.Solutions.Y24.Day08 do
alias AdventOfCode.Grid
alias AoC.Input
def parse(input, _part) do
{_grid, _bounds} =
input
|> Input.stream!()
|> Grid.parse_lines(fn
_, ?. -> :ignore
_, ?\n -> raise "parses new line"
_, c -> {:ok, c}
end)
end
def part_one({grid, bounds}) do
for({xy_l, l} <- grid, {xy_r, r} <- grid, l == r, xy_l < xy_r, do: antinodes_p1(xy_l, xy_r))
|> :lists.flatten()
|> Enum.uniq()
|> Enum.filter(&in_bounds?(&1, bounds))
|> length()
end
defp antinodes_p1({xl, yl}, {xr, yr}) do
x_diff = xr - xl
y_diff = yr - yl
[
# Lower node
{xl - x_diff, yl - y_diff},
# Higher node
{xr + x_diff, yr + y_diff}
]
end
defp in_bounds?({x, y}, {xa, xo, ya, yo}) do
x >= xa and x <= xo and
y >= ya and y <= yo
end
def part_two({grid, bounds}) do
for(
{xy_l, l} <- grid,
{xy_r, r} <- grid,
l == r,
xy_l < xy_r,
do: antinodes_p2(xy_l, xy_r, bounds)
)
|> :lists.flatten()
|> Enum.uniq()
|> length()
end
defp antinodes_p2({xl, yl}, {xr, yr}, bounds) do
x_diff = xr - xl
y_diff = yr - yl
higher =
{xr, yr}
|> Stream.iterate(fn {x, y} -> {x + x_diff, y + y_diff} end)
|> Enum.take_while(&in_bounds?(&1, bounds))
lower =
{xl, yl}
|> Stream.iterate(fn {x, y} -> {x - x_diff, y - y_diff} end)
|> Enum.take_while(&in_bounds?(&1, bounds))
[higher, lower]
end
end
No optimization at all 
its under 1ms as well.
1 Like
My solution today:
That’s a clever way of iterating through the grid.
I did a Map.values() into a MapSet to get possible values, then did a Map.filter() on each to get the matching tower locations, which seems messy in comparison 
.
1 Like
The grid ones are tricky to golf.
LOC: 23
defmodule Aoc2024.Day08 do
import Enum
def part1(file), do: main(file, 1..1)
def part2(file), do: main(file)
def main(file, range \\ nil) do
{grid, n} = file_to_charmap_grid(file)
for {{x1, y1}, z1} <- grid, {{x2, y2}, z2} <- grid, z1 == z2, z1 != ?., x1 < x2 do
map(range || -n..n, fn m -> {m * (x2 - x1), m * (y2 - y1)} end)
|> flat_map(fn {dx, dy} -> [[x1 - dx, y1 - dy], [x2 + dx, y2 + dy]] end)
|> filter(fn coor -> all?(coor, &(&1 in 0..(n - 1))) end)
end
|> reduce(MapSet.new(), &MapSet.union(&2, MapSet.new(&1)))
|> MapSet.size()
end
def file_to_charmap_grid(f) do
r = f |> File.read!() |> String.trim() |> String.split("\n") |> map(&String.to_charlist/1)
{for({s, i} <- with_index(r), {x, j} <- with_index(s), into: %{}, do: {{i, j}, x}), length(r)}
end
end
This one made me wish I could reach for the extra comprehension powers hinted at in the for let proposal.
4 Likes
Here is mine:
defmodule Aoc2024.Solutions.Y24.Day08 do
alias AoC.Input
def parse(input, _part) do
stream = Input.stream!(input, trim: true)
antennas =
stream
|> Stream.with_index()
|> Enum.reduce(%{}, fn {line, x}, antennas ->
line
|> String.to_charlist()
|> Stream.with_index()
|> Enum.reduce(antennas, fn
{?., _}, antennas -> antennas
{symbol, y}, antennas -> Map.update(antennas, symbol, [{x, y}], &[{x, y} | &1])
end)
end)
|> Map.values()
row_end = Enum.count(stream) - 1
col_end = length(String.to_charlist(Enum.at(stream, 0))) - 1
{antennas, row_end, col_end}
end
def part_one({antennas, row_end, col_end}) do
antennas
|> generate_combinations()
|> Enum.reduce(MapSet.new(), fn combinations, antinodes ->
Enum.reduce(combinations, antinodes, fn {{x1, y1}, {x2, y2}}, antinodes ->
antinodes
|> add_antinodes(x1, y1, x2 - x1, y2 - y1, row_end, col_end)
|> add_antinodes(x2, y2, x1 - x2, y1 - y2, row_end, col_end)
end)
end)
|> Enum.count()
end
def part_two({antennas, row_end, col_end}) do
antennas
|> generate_combinations()
|> Enum.reduce(MapSet.new(List.flatten(antennas)), fn combinations, antinodes ->
Enum.reduce(combinations, antinodes, fn {{x1, y1}, {x2, y2}}, antinodes ->
antinodes
|> add_antinodes_recursive(x1, y1, x2 - x1, y2 - y1, row_end, col_end)
|> add_antinodes_recursive(x2, y2, x1 - x2, y1 - y2, row_end, col_end)
end)
end)
|> Enum.count()
end
defp generate_combinations(antennas) do
for antenna <- antennas do
for {a, x} <- Enum.with_index(antenna),
{b, y} <- Enum.with_index(antenna),
x < y,
do: {a, b}
end
end
defp add_antinodes(antinodes, x_original, y_original, dx, dy, row_end, col_end) do
{x, y} = {x_original - dx, y_original - dy}
if x >= 0 and x <= row_end and y >= 0 and y <= col_end do
MapSet.put(antinodes, {x, y})
else
antinodes
end
end
defp add_antinodes_recursive(antinodes, x_original, y_original, dx, dy, row_end, col_end) do
{x, y} = {x_original - dx, y_original - dy}
if x >= 0 and x <= row_end and y >= 0 and y <= col_end do
antinodes = MapSet.put(antinodes, {x, y})
add_antinodes_recursive(antinodes, x, y, dx, dy, row_end, col_end)
else
antinodes
end
end
end
Can somebody explain to me why is part 2 faster although it’s the same kind of function for calculation as in part 1 only recursive. 
Solution for 2024 day 8
part_one: 376 in 8.85ms
part_two: 1352 in 1.22ms
@ken-kost your part 1 was faster for me. I’m not using aoc though so that might have something to do with it?
I ran:
Benchee.run(%{
"part1" => fn ->
"inputs/day08/input2.txt"
|> Aoc2024.Solutions.Y24.Day08.parse(1)
|> Aoc2024.Solutions.Y24.Day08.part_one()
end,
"part2" => fn ->
"inputs/day08/input2.txt"
|> Aoc2024.Solutions.Y24.Day08.parse(2)
|> Aoc2024.Solutions.Y24.Day08.part_two()
end
})
After replacing the Aoc.Input part with:
# Before
stream = Input.stream!(input, trim: true)
# After
stream =
input
|> File.stream!()
|> Stream.map(&String.trim/1)
|> Stream.reject(&(&1 == ""))
and I got:
Name ips average deviation median 99th %
part1 1.25 K 0.80 ms ±39.13% 0.75 ms 1.43 ms
part2 0.99 K 1.01 ms ±19.68% 0.95 ms 1.70 ms
1 Like
Today’s problem is more like a reading comprehension problem than an algorithm problem, especially for a non English native speaker. Fortunately, I was a student of physics when I was at university, and this problem brings me back to those days.
I really liked how this worked out in the end <3
and i like to use structs as you can see. It saves me from hidden issues like calling non existing keys on maps … and getting nil back …
i just changed the existing part1 soluition for part2 as always
this was a fun excercice
btw i see most of you try to make it as few lines of possible and as fast as possible … but i just sincerely enjoy doing the exercises 
I wonder what i will do rest of the year now, after december … excercism ?
There’s always previous year puzzles to do, if you haven’t done those!
https://everybody.codes/ is anothe one that popped up last month for more puzzley goodness
2 Likes
Catching back up.
Here’s my pt 1:
#!/usr/bin/env elixir
defmodule Day8.Part1 do
@open_space ~c"." |> List.first()
defp parse(str) do
[row | _rows] =
rows =
str
|> String.split("\n")
|> Enum.map(&to_charlist/1)
height = Enum.count(rows)
length = Enum.count(row)
antennae =
for y <- 0..(height - 1), x <- 0..(length - 1) do
{x, y}
end
|> Enum.reduce(
%{},
fn {x, y} = pos, acc ->
c = rows |> Enum.at(y) |> Enum.at(x)
if c == @open_space,
do: acc,
else: acc |> Map.update("#{c}", [pos], fn coordinates -> [pos | coordinates] end)
end
)
%{
antennae: antennae,
height: height,
length: length
}
end
defp on_board?(height, length, {x, y}) when x < 0 or x >= length or y < 0 or y >= height,
do: false
defp on_board?(_height, _length, _pair), do: true
# Produce a List of coordinate pairs representing antinodes
defp pairwise_antinodes_on_board(height, length, antennae) do
Stream.unfold(
antennae,
fn
[] -> nil
[_h | t] = antennae -> {antennae, t}
end
)
|> Enum.map(fn antennae -> pairwise_antinodes_on_board_for_antenna(antennae, height, length) end)
|> List.flatten()
end
defp pairwise_antinodes_on_board_for_antenna(
[_antenna],
_height,
_length
),
do: []
defp pairwise_antinodes_on_board_for_antenna(
[{x_1, y_1} = antenna_1, {x_2, y_2} = _antenna_2 | antennae],
height,
length
)
when abs(x_1 - x_2) > length / 2 or abs(y_1 - y_2) > height / 2,
do: pairwise_antinodes_on_board_for_antenna([antenna_1 | antennae], height, length)
defp pairwise_antinodes_on_board_for_antenna(
[{x_1, y_1} = antenna_1, {x_2, y_2} = _antenna_2 | antennae],
height,
length
) do
south_ish? = y_2 - y_1 < 0
west_ish? = x_2 - x_1 < 0
{x_min, x_max} = Enum.min_max([x_1, x_2])
delta_x = abs(x_1 - x_2)
{y_min, y_max} = Enum.min_max([y_1, y_2])
delta_y = abs(y_1 - y_2)
{antinode_1_x, antinode_2_x} =
if west_ish? do
{x_max + delta_x, x_min - delta_x}
else
{x_min - delta_x, x_max + delta_x}
end
{antinode_1_y, antinode_2_y} =
if south_ish? do
{y_max + delta_y, y_min - delta_y}
else
{y_min - delta_y, y_max + delta_y}
end
[
[{antinode_1_x, antinode_1_y}, {antinode_2_x, antinode_2_y}]
|> Enum.filter(&on_board?(height, length, &1))
| pairwise_antinodes_on_board_for_antenna([antenna_1 | antennae], height, length)
]
|> List.flatten()
end
defp count_antinodes(%{
antennae: antennae,
height: height,
length: length
}) do
antennae
|> Map.keys()
|> Enum.reduce(
MapSet.new(),
fn frequency, antinodes ->
pairwise_antinodes_on_board(height, length, antennae[frequency])
|> Enum.reduce(antinodes, &MapSet.put(&2, &1))
end
)
|> Enum.count()
end
def solve() do
File.read!("08/input.txt")
|> parse()
|> count_antinodes()
|> IO.puts()
end
end
Day8.Part1.solve()
And part 2:
#!/usr/bin/env elixir
defmodule Day8.Part1 do
@open_space ~c"." |> List.first()
defp parse(str) do
[row | _rows] =
rows =
str
|> String.split("\n")
|> Enum.map(&to_charlist/1)
height = Enum.count(rows)
length = Enum.count(row)
antennae =
for y <- 0..(height - 1), x <- 0..(length - 1) do
{x, y}
end
|> Enum.reduce(
%{},
fn {x, y} = pos, acc ->
c = rows |> Enum.at(y) |> Enum.at(x)
if c == @open_space,
do: acc,
else: acc |> Map.update("#{c}", [pos], fn coordinates -> [pos | coordinates] end)
end
)
%{
antennae: antennae,
height: height,
length: length
}
end
defp pairwise_antinodes_on_board(height, length, antennae) do
Stream.unfold(
antennae,
fn
[] -> nil
[_h | t] = antennae -> {antennae, t}
end
)
|> Enum.map(fn antennae -> pairwise_antinodes_on_board_for_antenna(antennae, height, length) end)
|> List.flatten()
end
defp pairwise_antinodes_on_board_for_antenna(
[_antenna],
_height,
_length
),
do: []
defp pairwise_antinodes_on_board_for_antenna(
[{x_1, y_1} = antenna_1, {x_2, y_2} = _antenna_2 | antennae],
height,
length
) do
south_ish? = y_2 - y_1 < 0
west_ish? = x_2 - x_1 < 0
{x_min, x_max} = Enum.min_max([x_1, x_2])
delta_x = x_max - x_min
{y_min, y_max} = Enum.min_max([y_1, y_2])
delta_y = y_max - y_min
north_eastern = [x_max..(length - 1)//delta_x, y_max..(height - 1)//delta_y]
south_western = [x_min..0//-delta_x, y_min..0//-delta_y]
south_eastern = [x_max..(length - 1)//delta_x, y_min..0//-delta_y]
north_western = [x_min..0//-delta_x, y_max..(height - 1)//delta_y]
[antinodes_1, antinodes_2] =
if west_ish? and south_ish? or (not west_ish? and not south_ish?) do
[south_western, north_eastern]
else
[south_eastern, north_western]
end
|> Enum.map(
fn ranges ->
ranges
|> Enum.map(&Enum.to_list(&1))
|> Enum.zip()
end
)
[
antinodes_1 | [antinodes_2 | pairwise_antinodes_on_board_for_antenna([antenna_1 | antennae], height, length)]
]
|> List.flatten()
end
defp count_antinodes(%{
antennae: antennae,
height: height,
length: length
}) do
antennae
|> Map.keys()
|> Enum.reduce(
MapSet.new(),
fn frequency, antinodes ->
pairwise_antinodes_on_board(height, length, antennae[frequency])
|> Enum.reduce(antinodes, &MapSet.put(&2, &1))
end
)
|> Enum.count()
end
def solve() do
File.read!("08/input.txt")
|> parse()
|> count_antinodes()
|> IO.puts()
end
end
Day8.Part1.solve()
A bit of a crude solution, particularly when it came to part2. Copy/paste/modify got the job done without bothering to refactor anything. Trying to get caught up.
defmodule Aoc2024.Day8 do
@moduledoc false
defp coord(i, width) do
{Integer.mod(i, width), Integer.floor_div(i, width)}
end
defp get_bounds(data) do
map =
data
|> String.split("\n", trim: true)
|> Enum.map(&String.split(&1, "", trim: true))
{length(List.first(map)) - 1, length(map) - 1}
end
defp get_input(data) do
map =
data
|> String.split("\n", trim: true)
|> Enum.map(&String.split(&1, "", trim: true))
width = length(List.first(map))
data
|> String.replace("\n", "")
|> String.split("", trim: true)
|> Enum.with_index()
|> Enum.filter(fn {c, _} -> c != "." end)
|> Enum.reduce(Map.new(), fn {v, i}, antennas ->
Map.update(antennas, v, [coord(i, width)], fn s ->
[coord(i, width) | s]
end)
end)
end
# Generate the pair of antinodes for a given pair of nodes.
defp antinode(a = {ax, ay}, b = {bx, by}) do
dx = bx - ax
dy = by - ay
if a != b, do: [{ax - dx, ay - dy}, {bx + dx, by + dy}], else: []
end
# Generate all antinodes including those out of bounds and duplicates.
defp find_antinodes(antennas) do
for locations <- Map.values(antennas) do
for a <- locations, b <- locations do
antinode(a, b)
end
end
end
defp in_bounds?({x, y}, {last_x, last_y}) do
x >= 0 and x <= last_x and y >= 0 and y <= last_y
end
def part1(file) do
data = File.read!(file)
get_input(data)
|> find_antinodes()
|> List.flatten()
|> Enum.uniq()
|> Enum.filter(&in_bounds?(&1, get_bounds(data)))
|> Enum.count()
end
# Generate all antinodes for a pair of antennas radiating outward.
defp antinode2(a = {ax, ay}, b = {bx, by}, mult \\ 1) do
# Cheating a bit here instead of passing in the maximum position indexes.
size = 49
dx = (bx - ax) * mult
dy = (by - ay) * mult
if a == b do
[a]
else
n = {ax - dx, ay - dy}
m = {bx + dx, by + dy}
if not in_bounds?(n, {size, size}) and not in_bounds?(m, {size, size}) do
[]
else
[n | [m | antinode2(a, b, mult + 1)]]
end
end
end
defp find_antinodes2(antennas) do
for locations <- Map.values(antennas) do
for a <- locations, b <- locations do
antinode2(a, b)
end
end
end
def part2(file) do
data = File.read!(file)
get_input(data)
|> find_antinodes2()
|> List.flatten()
|> Enum.uniq()
|> Enum.filter(&in_bounds?(&1, get_bounds(data)))
|> Enum.sort()
|> Enum.count()
end
end
