My solution. I solved Part 2 manually by printing each second’s grid, too. For part 1 I was also inspired by the solutions already posted in this thread.
https://github.com/Flo0807/adventofcode/blob/main/2024/14.livemd
Flo0807
antoine-duchenet
I did solve part 1 with simple modulo operations like most of us.
Concerning part 2, I did render the “animation” (at x4 speed) in my console.
2 patterns appeared for the first time in the first 100 frames and then reappeared regularly respectively every 101 and 103 frames.
With the guess that the Christmas tree appears when both patterns are applied to the same frame, the chinese remainder theorem gave me the solution.
2
rvnash
Oh my, I am not proud of my Part 2. My is_a_christmas_tree?/1 function is the absolute worst. It took 272 seconds to get to the answer.
https://github.com/rvnash/aoc2024/blob/main/lib/d14.ex
But, lots of decorating to do today, moving on.
0
glomph
I had an annoying bug with my home made mod function that meant part1 took longer than it should. Nice to learn about Integer.mod. Do you think it would be good to add a note about the existance of Integer.mod to the documentation for rem()?
For part 2 I tried various huristics until I decided to reuse the regions finding function from day 12. That worked fine but was lucky as they could have easily drawn a tree without touching. I was very close to realising I could have looked for seconds where they are in unique positons (although again that is just a heuristic I guess).
1
bossek
Finding minimal variance of positions worked for me in part 2. For each second in range 0..(101 * 103) I’ve calculated variance of robots’ positions:
defp variance(positions) do
{xs, ys} = Enum.unzip(positions)
xl = length(xs)
yl = length(ys)
xmean = Enum.sum(xs) / xl
ymean = Enum.sum(ys) / yl
xvar = Enum.sum(Enum.map(xs, fn x -> (x - xmean) ** 2 end)) / xl
yvar = Enum.sum(Enum.map(ys, fn y -> (y - ymean) ** 2 end)) / yl
(xvar + yvar) / 2
end
The second with minimal variance was the solution.
5
gazzer82
Went for a semi, brute force method here. Generated .txt files of the first 200 options, spotted that there was a sequence of when the robots seemed to come together, so then decided to try searching for a block of xxxx in the txt representation of the grid, and I was lucky!
Should really tidy it up to not be converting to a string every time for speed, but it works and I’m short on time today!
defmodule Aoc2024.Solutions.Y24.Day14 do
alias AoC.Input
def parse(input, _part) do
Input.read!(input)
|> String.split("\n", trim: true)
|> Enum.map(fn robot ->
[rob, speed] = String.split(robot, " ", trim: true)
{get_x_y(rob), get_x_y(speed)}
end)
end
def get_x_y(loc) do
[x, y] = String.split(loc, ",", trim: true)
x = String.split(x, "=", trim: true) |> List.last() |> String.to_integer()
y = String.to_integer(y)
{x, y}
end
def part_one(problem) do
grid_x = 100
grid_y = 102
middle_x = 50
middle_y = 51
{a, b, c, d} =
problem
|> perform_moves({grid_x, grid_y}, 100, 0)
# |> Enum.map(&perform_moves(&1, {grid_x, grid_y}, 100, 0))
|> Enum.reduce({0, 0, 0, 0}, fn robot, acc ->
acc = find_quadrant(robot, acc, {middle_x, middle_y})
acc
end)
a * b * c * d
end
def part_two(problem) do
grid_x = 100
grid_y = 102
problem
|> perform_moves_pt_2({grid_x, grid_y}, 8000, 0)
end
def find_quadrant(
{{loc_x, loc_y}, _},
{quad_1, quad_2, quad_3, quad_4} = acc,
{middle_x, middle_y}
) do
cond do
loc_x < middle_x && loc_y < middle_y ->
{quad_1 + 1, quad_2, quad_3, quad_4}
loc_x > middle_x && loc_y < middle_y ->
{quad_1, quad_2 + 1, quad_3, quad_4}
loc_x < middle_x && loc_y > middle_y ->
{quad_1, quad_2, quad_3 + 1, quad_4}
loc_x > middle_x && loc_y > middle_y ->
{quad_1, quad_2, quad_3, quad_4 + 1}
true ->
acc
end
end
def perform_moves(robots, {_grid_x, _grid_y}, count, acc) when acc == count, do: robots
def perform_moves(robots, {grid_x, grid_y}, count, acc) do
robots =
Enum.map(robots, fn robot ->
perform_move(robot, {grid_x, grid_y})
end)
perform_moves(robots, {grid_x, grid_y}, count, acc + 1)
end
def perform_moves_pt_2(robots, {_grid_x, _grid_y}, count, acc) when acc == count, do: robots
@first_1 59
@diff_1 103
@tick_1 Enum.map(1..100, fn n -> @first_1 + (n - 1) * @diff_1 end)
@first_2 82
@diff_2 101
@tick_2 Enum.map(1..100, fn n -> @first_2 + (n - 1) * @diff_2 end)
@ticks @tick_1 ++ @tick_2
def perform_moves_pt_2(robots, {grid_x, grid_y}, count, acc) do
robots =
Enum.map(robots, fn robot ->
perform_move(robot, {grid_x, grid_y})
end)
if acc in @ticks do
if check_for_tree(robots) do
acc
else
perform_moves_pt_2(robots, {grid_x, grid_y}, count, acc + 1)
end
else
perform_moves_pt_2(robots, {grid_x, grid_y}, count, acc + 1)
end
end
def check_for_tree(robots) do
grid = for _ <- 0..102, do: for(_ <- 0..100, do: ".")
Enum.reduce(robots, grid, fn {{x, y}, _}, acc ->
List.update_at(acc, y, fn row ->
List.update_at(row, x, fn _ -> "#" end)
end)
end)
|> Enum.join(" ")
|> String.contains?("##########")
end
def print_coordinates_grid(coordinates, acc) do
grid = for _ <- 0..102, do: for(_ <- 0..100, do: ".")
updated_grid =
Enum.reduce(coordinates, grid, fn {{x, y}, _}, acc ->
List.update_at(acc, y, fn row ->
List.update_at(row, x, fn _ -> "#" end)
end)
end)
file =
Enum.reduce(updated_grid, "", fn row, acc ->
acc <> Enum.join(row, "") <> "\n"
end)
File.write!("output_#{acc}.txt", file)
end
def perform_move({{x, y}, {speed_x, speed_y}}, {grid_x, grid_y}) do
updated_x = calulate_next_position(x, speed_x, grid_x)
updated_y = calulate_next_position(y, speed_y, grid_y)
{{updated_x, updated_y}, {speed_x, speed_y}}
end
def calulate_next_position(current, speed, grid_size) when current + speed > grid_size do
current - 1 + speed - grid_size
end
def calulate_next_position(current, speed, grid_size) when current + speed < 0 do
grid_size + 1 + current + speed
end
def calulate_next_position(current, speed, _grid_size) do
current + speed
end
end
0
MikeLindner
Had to come here to get some idea of what the christmas tree was supposed to look like so I could figure out how to search for it. Once I knew that it was fairly straightforward since I had written function to output a grid layout for debugging for a previous day.
AOC continues to be a great way for me to learn the Elixir standard library. I think I’ve used a new-to-me function every day.
require Grid
defmodule Aoc2024.Day14 do
@moduledoc false
def part1(file, size) do
seconds = 100
get_input(file)
|> Enum.map(&move(&1, seconds, size))
|> Enum.map(&quadrant(&1, size))
|> Enum.frequencies()
|> Map.delete(0)
|> Map.values()
|> Enum.product()
end
def part2(file, size) do
robots = get_input(file)
Enum.reduce_while(1..10_000, robots, fn seconds, robots ->
output = Enum.map(robots, &move(&1, seconds, size))
|> Enum.frequencies()
|> Grid.new(size)
|> Grid.output(" ")
if Regex.match?(~r/\d{8}/, output) do
IO.puts("#{seconds} seconds:")
IO.puts(output)
{:halt, seconds}
else
{:cont, robots}
end
end)
end
defp get_input(file) do
File.read!(file)
|> String.trim()
|> String.split("\n", trim: true)
|> Enum.map(fn line ->
[px, py, vx, vy] =
Regex.run(~r/p=(?<px>\d+),(?<py>\d+) v=(?<vx>-?\d+),(?<vy>-?\d+)/, line,
capture: ["px", "py", "vx", "vy"]
)
|> Enum.map(&String.to_integer/1)
{px, py, vx, vy}
end)
end
defp move(_robot = {px, py, vx, vy}, seconds, _size = {sx, sy}) do
newx = Integer.mod(px + vx * seconds, sx)
newy = Integer.mod(py + vy * seconds, sy)
{newx, newy}
end
defp quadrant(_robot_position = {px, py}, _size = {sx, sy}) do
midx = div(sx, 2)
midy = div(sy, 2)
cond do
px == midx or py == midy ->
0
px < midx and py < midy ->
1
px > midx and py < midy ->
2
px < midx and py > midy ->
3
px > midx and py > midy ->
4
end
end
end
1
mwilsoncoding
For whatever reason, this is correct for the example, but incorrect for the input. I’m confused as to why. My initial implementation looked a lot like @adamu’s. I’ve since refactored it to be nearly identical, but it still doesn’t pass. ← see my reply. This works with a different regex.
I also noticed that the final output for the example has one robot at position 9,0 instead of 10,0 where my code calculates it. 
Maybe a typo in the example output?
Anyone able to point me in the right direction?
defmodule Day14.Part1 do
@seconds 100
@width 101
@height 103
@center_column div(@width, 2)
@center_row div(@height, 2)
defp parse(str) do
str
|> String.split("\n", trim: true)
|> Enum.map(&parse_bot/1)
end
defp parse_bot(line) do
Regex.scan(~r/-?\d,-?\d/, line)
|> Enum.flat_map(fn [pair] ->
[
String.split(pair, ",")
|> Enum.map(&String.to_integer/1)
|> List.to_tuple()
]
end)
end
defp iterate(bots) do
bots
|> Enum.reduce(
{0,0,0,0},
fn [{p_x, p_y}, {v_x, v_y}] = _bot, {q1_bots, q2_bots, q3_bots, q4_bots} = bots ->
delta_x = v_x * @seconds
delta_y = v_y * @seconds
final_x = Integer.mod(p_x + delta_x, @width)
final_y = Integer.mod(p_y + delta_y, @height)
case {final_x, final_y} do
{x, y} when x < @center_column and y < @center_row -> {q1_bots + 1, q2_bots, q3_bots, q4_bots}
{x, y} when x < @center_column and y > @center_row -> {q1_bots, q2_bots + 1, q3_bots, q4_bots}
{x, y} when x > @center_column and y < @center_row -> {q1_bots, q2_bots, q3_bots + 1, q4_bots}
{x, y} when x > @center_column and y > @center_row -> {q1_bots, q2_bots, q3_bots, q4_bots + 1}
_ -> bots
end
end
)
|> Tuple.product()
end
def solve() do
File.read!("lib/advent_of_code/year/2024/day/14/input.txt")
|> parse()
|> dbg()
|> iterate()
|> IO.puts()
end
end
0
mwilsoncoding
Woops. Got it.
My regex for parsing was missing + chars after matching each \d 
Working regex for the above code: ~r/-?\d+,-?\d+/
0
lkuty
Read some comments here and on Reddit to get some ideas and eventually tried finding an horizontal line of at least 10 robots. Should have found it by myself. Anyway, it was a cool one.
#!/usr/bin/env elixir
# AoC 2024. day 14.
to_i = &String.to_integer/1
advance = fn robots, sec ->
Enum.map(robots, fn robot ->
%{robot |
x: Integer.mod(robot.x+sec*robot.vx,101),
y: Integer.mod(robot.y+sec*robot.vy,103) }
end)
# sorting is used in part 2
|> Enum.sort(fn o1, o2 -> o1.y < o2.y || o1.y == o2.y && o1.x <= o2.x end)
end
count = fn robots ->
Enum.reduce(robots, {0,0,0,0}, fn robot, {q1,q2,q3,q4} ->
cond do
robot.x < 50 && robot.y < 51 -> {q1+1,q2,q3,q4}
robot.x > 50 && robot.y < 51 -> {q1,q2+1,q3,q4}
robot.x < 50 && robot.y > 51 -> {q1,q2,q3+1,q4}
robot.x > 50 && robot.y > 51 -> {q1,q2,q3,q4+1}
true -> {q1,q2,q3,q4}
end
end)
end
###########################################################
# Setup
robots = File.stream!("../day14.txt")
|> Stream.map(fn s -> Regex.run(~r/^p=(\d+),(\d+) v=(-?\d+),(-?\d+)/, s, capture: :all_but_first) end)
|> Enum.reduce([], fn [x, y, vx, vy], lst -> [%{x: to_i.(x), y: to_i.(y), vx: to_i.(vx), vy: to_i.(vy)} | lst] end)
# sorting is used in part 2
|> Enum.sort(fn o1, o2 -> o1.y < o2.y || o1.y == o2.y && o1.x <= o2.x end)
###########################################################
# Part 1
start = System.monotonic_time(:microsecond)
robots
|> advance.(100)
|> count.()
|> then(fn {q1,q2,q3,q4} -> q1*q2*q3*q4 end)
|> IO.inspect(label: "Part 1")
elapsed = System.monotonic_time(:microsecond) - start
IO.puts "Job done in #{elapsed} µs"
###########################################################
# Part 2
defmodule M do
@min_aligned 10
def horizontal_line(robots), do: horizontal_line(robots, 0, nil)
defp horizontal_line([], aligned, _prev), do: aligned >= @min_aligned
defp horizontal_line([r | robots], 0, nil), do: horizontal_line(robots, 0, r)
defp horizontal_line([r | robots], aligned, prev) do
cond do
aligned >= @min_aligned -> true
r.y == prev.y && r.x == prev.x+1 -> horizontal_line(robots, aligned+1, r)
true -> horizontal_line(robots, 0, r)
end
end
end
display = fn robots, x0, y0, width, height ->
robots = Map.new(robots, fn r -> {{r.x,r.y},{r.vx,r.vy}} end)
for y <- y0..y0+height, x <- x0..x0+width, reduce: y0 do
prev_y -> if y != prev_y, do: IO.puts("")
if robots[{x,y}] do
IO.write "#"
else
IO.write "."
end
y
end
IO.puts ""
end
start = System.monotonic_time(:microsecond)
Stream.iterate({robots, 0}, fn {robots, time} ->
robots = advance.(robots, 1)
{robots, time+1}
end)
|> Stream.drop_while(fn {robots, _time} ->
!M.horizontal_line(robots)
end)
|> Enum.at(0)
|> then(fn {robots, time} -> display.(robots, 0, 0, 101, 103) ; time end)
|> IO.inspect(label: "Part 2")
elapsed = System.monotonic_time(:microsecond) - start
IO.puts "Job done in #{elapsed} µs"
0