I think that the infinite solns problems would always have the nature that the two lines described by the rows of the matrices would be parallel. Meaning “they never cross”, hence the determinant is 0. The only way to get a solution, therefore, is if both the X and Y coordinate equations are right on top of each other. So, then you only need to hit as many A’s as you need to to get to an even multiple of B distance, and then use B from then on out. It wouldn’t be hard to solve, sort of a remainder type problem. But that would have added another twist. One twist too many perhaps, as you pointed out.
rvnash
Flo0807
My solution:
# Parsing
puzzles =
puzzle_input
|> String.split("\n", trim: true)
|> Enum.chunk_every(3)
|> Enum.map(fn machine ->
Enum.map(machine, fn row ->
[[_patternx, x], [_patterny, y]] = Regex.scan(~r/[XY][+=](\d+)/, row)
{String.to_integer(x), String.to_integer(y)}
end)
end)
defmodule ClawContraption do
# ax * x + bx * y = px
# ay * x + by * y = py
def solve([{ax, ay}, {bx, by}, {px, py}]) do
case ax * by - bx * ay do
0 ->
0
determinant ->
num_x = px * by - bx * py
num_y = ax * py - px * ay
if rem(num_x, determinant) == 0 and rem(num_y, determinant) == 0 do
x = div(num_x, determinant)
y = div(num_y, determinant)
{x, y}
else
0
end
end
end
def calculate_cost({x, y}), do: x * 3 + y
def calculate_cost(_result), do: 0
end
# Puzzle 1
Enum.map(puzzles, fn puzzle ->
puzzle
|> ClawContraption.solve()
|> ClawContraption.calculate_cost()
end)
|> Enum.sum()
# Puzzle 2
Enum.map(puzzles, fn puzzle ->
[{ax, ay}, {bx, by}, {px, py}] = puzzle
[{ax, ay}, {bx, by}, {px + 10_000_000_000_000, py + 10_000_000_000_000}]
|> ClawContraption.solve()
|> ClawContraption.calculate_cost()
end)
|> Enum.sum()
Full code:
https://github.com/Flo0807/adventofcode/blob/main/2024/13.livemd
1
rvnash
hauleth
Simple Cramer’s rule for solving linear equations, and some small writeup about it.
https://github.com/hauleth/advent-of-code/blob/master/2024/day13.livemd
4
seeplusplus
mwilsoncoding
The async stream and the cartesian iteration limit for j were a bit extra, but it works for part 1:
defmodule Day13.Part1 do
@max_presses 100
@a_cost 3
@b_cost 1
defp parse_machine_args(machine_args) when is_list(machine_args) do
machine_args
|> Enum.reduce(
%{},
fn arg, machine ->
{key, value} = parse_arg(arg)
machine |> Map.put(key, value)
end
)
end
defp parse_arg("Button A: " <> a_vector), do: {:a, parse_point(a_vector)}
defp parse_arg("Button B: " <> b_vector), do: {:b, parse_point(b_vector)}
defp parse_arg("Prize: " <> point), do: {:prize, parse_point(point)}
defp parse_point("X" <> rest) do
~r/\d+/
|> Regex.scan(rest)
|> List.flatten()
|> Enum.map(&String.to_integer/1)
|> List.to_tuple()
end
defp parse(str) do
str
|> String.split("\n")
|> Stream.chunk_by(&(&1 == ""))
|> Stream.filter(&(&1 != [""]))
|> Enum.map(&parse_machine_args/1)
end
defp treasure_maps(%{a: {x_a, y_a}, b: {x_b, y_b}, prize: {target_x, target_y}} = _machine) do
for i <- 0..@max_presses do
leftover_x = target_x - (x_a * i)
js_that_can_fit_x = div(leftover_x, x_b)
j_limit = min(target_x, js_that_can_fit_x)
leftover_y = target_y - (y_a * i)
js_that_can_fit_y = div(leftover_y, y_b)
j_limit = min(j_limit, js_that_can_fit_y)
j_limit = min(j_limit, @max_presses)
for j <- 0..j_limit do
x_combined = i * x_a + j * x_b
y_combined = i * y_a + j * y_b
{x_combined, y_combined, i, j}
end
|> Enum.filter(fn {x, y, _i, _j} -> x == target_x and y == target_y end)
end
|> Enum.flat_map(& &1)
end
defp min_cost(machine) do
case treasure_maps(machine) do
[] ->
0
hits ->
hits
|> Enum.map(fn {_x, _y, a, b} -> a * @a_cost + b * @b_cost end)
|> Enum.min()
end
end
defp score_min_costs(machines) do
machines
|> Task.async_stream(&min_cost/1)
|> Enum.reduce(0, fn {:ok, min_cost}, acc ->
acc + min_cost
end)
end
def solve() do
File.read!("lib/advent_of_code/year/2024/day/13/input.txt")
|> parse()
|> score_min_costs()
|> IO.puts()
end
end
Still working on part 2 =]
0
mwilsoncoding
jarlah
Lets hope day 13 is not evil and destroys my brain 
like day12
I got the example input with four machines to work. My code returns 480 for that input
but it seems its returning a false cost for the actual input. Which tells me i need to go back to the drawing board
1
jarlah
Nope. Brain failing to understand. IF I understand the requirements correctly, the first example that cost 480 tokens should be a minimal example for the bigger answer. Is that a wrong assumption? I might not able to parse the English in the text, even though I’m pretty fluent.
da code:
https://github.com/jarlah/advent_of_code/blob/master/lib/2024/day_13/Part1.ex#L33
Hints?
for ex is this
So, the most prizes you could possibly win is two; the minimum tokens you would have to spend to win all (two) prizes is `480`.
the same as this
Figure out how to win as many prizes as possible. *What is the fewest tokens you would have to spend to win all possible prizes?
0
sevenseacat
Author of Ash Framework
You need to check your reached_target? function, the logic there looks wrong.
At the moment your only “don’t win” case is if you reach 100 presses without winning.
2