Simple Cramer’s rule for solving linear equations, and some small writeup about it.

Solved w/ Nx:

Solving a 2x2 is a nice little demo of using Nx as an introduction.

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.

I wrote the simple algebraic solution that Part 2 needed first, but assumed it was going to miss the cheapest solution if there were multiple, so I ran an exhaustive search to solve Part 1.
That was obviously not going to be suitable for Part 2 so I went back to see how much massageing it was going to need, and the answer was None!

def parse(input) do
    input
    |> String.split("\n", trim: true)
    |> Enum.chunk_every(3)
    |> Enum.map(fn [a, b, p] ->
      [ax, ay] =
        String.split(a, ["Button A: X+", ", Y+"], trim: true) |> Enum.map(&String.to_integer/1)

      [bx, by] =
        String.split(b, ["Button B: X+", ", Y+"], trim: true) |> Enum.map(&String.to_integer/1)

      [px, py] =
        String.split(p, ["Prize: X=", ", Y="], trim: true) |> Enum.map(&String.to_integer/1)

      {{ax, ay}, {bx, by}, {px, py}}
    end)
  end

  def part1(input) do
    input
    |> parse()
    |> Enum.map(fn {{ax, ay}, {bx, by}, {px, py}} ->
      na = div(by * px - bx * py, by * ax - bx * ay)
      nb = div(ay * px - ax * py, ay * bx - ax * by)

      x = na * ax + nb * bx
      y = na * ay + nb * by

      if x == px and y == py do
        3 * na + nb
      else
        0
      end
    end)
    |> Enum.sum()
  end

  @scale 10_000_000_000_000

  def part2(input) do
    input
    |> parse()
    |> Enum.map(fn {{ax, ay}, {bx, by}, {px, py}} ->
      na = div(by * (px + @scale) - bx * (py + @scale), by * ax - bx * ay)
      nb = div(ay * (px + @scale) - ax * (py + @scale), ay * bx - ax * by)

      x = na * ax + nb * bx
      y = na * ay + nb * by

      if x == px + @scale and y == py + @scale do
        3 * na + nb
      else
        0
      end
    end)
    |> Enum.sum()
  end