Pretty much the same as everyone else’s. Passing functions and tail recursion makes this really clean. advent/2023/09.livemd at main · shritesh/advent · GitHub
shritesh
midouest
Converted part 1 to a simple visualization using Kino + VegaLite:
Code
alias VegaLite, as: Vl
defmodule Viz do
def difference(widget, history), do: difference(widget, history, [])
def difference(widget, prev_diffs, rest_diffs) do
i = length(rest_diffs)
data =
for {diff, x} <- Enum.with_index(prev_diffs) do
%{"x" => x, "y" => diff, "i" => i}
end
Kino.VegaLite.push_many(widget, data)
Process.sleep(div(500, i + 1))
if Enum.all?(prev_diffs, &(&1 == 0)) do
predictr(widget, [prev_diffs | rest_diffs])
else
next_diffs =
prev_diffs
|> Enum.chunk_every(2, 1, :discard)
|> Enum.map(fn xs -> Enum.reduce(xs, &Kernel.-/2) end)
difference(widget, next_diffs, [prev_diffs | rest_diffs])
end
end
def predictr(widget, diffs), do: predictr(widget, diffs, 0)
def predictr(_, [], extrapolation), do: extrapolation
def predictr(widget, [diffs | rest], extrapolation) do
next_extrapolation = extrapolation + List.last(diffs)
i = length(rest)
Kino.VegaLite.push(widget, %{
"x" => length(diffs),
"y" => next_extrapolation,
"i" => i
})
Process.sleep(div(500, i + 1))
predictr(widget, rest, next_extrapolation)
end
end
widget =
Vl.new(width: 600, height: 300)
|> Vl.mark(:line)
|> Vl.encode_field(:x, "x", type: :quantitative)
|> Vl.encode_field(:y, "y", type: :quantitative)
|> Vl.encode_field(:color, "i", type: :nominal)
|> Kino.VegaLite.render()
for history <- histories do
Kino.VegaLite.clear(widget)
Viz.difference(widget, history)
end
2
lud
These are the intermediate lists I found with my working solution:
12 20 25 35 64 137 305 670 1420 2874 5537 10165 17840 30055 48809 76712 117100 174160 253065 360119 502912
8 5 10 29 73 168 365 750 1454 2663 4628 7675 12215 18754 27903 40388 57060 78905 107054 142793
-3 5 19 44 95 197 385 704 1209 1965 3047 4540 6539 9149 12485 16672 21845 28149 35739
8 14 25 51 102 188 319 505 756 1082 1493 1999 2610 3336 4187 5173 6304 7590
6 11 26 51 86 131 186 251 326 411 506 611 726 851 986 1131 1286
5 15 25 35 45 55 65 75 85 95 105 115 125 135 145 155
10 10 10 10 10 10 10 10 10 10 10 10 10 10 10
0 0 0 0 0 0 0 0 0 0 0 0 0 0
1
trnasistor
Thank you! Turns out, I was wrong to take absolute value of the difference like so:
new_value = abs(head - List.first(tail))
Instead, I had to simply subtract the second value from the first
new_value = List.first(tail) - head
With this change, I got the right answer immediately.
2
stevensonmt
I thought the first few days had some excessively hard problems for early on but this was an oddly easy day. Part 2 was just not much of a challenge after part 1.
Code
defmodule Day9 do
@moduledoc """
Day9 AoC Solutions
"""
alias AocToolbox.Input
# add sample data here
def input(:test),
do: """
0 3 6 9 12 15
1 3 6 10 15 21
10 13 16 21 30 45
"""
def input(:real), do: Input.load(__DIR__ <> "/input.txt")
def solve(1, mode) do
__MODULE__.Part1.solve(input(mode))
end
def solve(2, mode) do
__MODULE__.Part2.solve(input(mode))
end
def parse(input) do
input
|> String.split("\n", trim: true)
|> Enum.map(&String.split(&1, ~r"\s"))
|> Enum.map(fn gs -> gs |> Enum.map(&String.to_integer/1) end)
end
def intervals(histories), do: Enum.map(histories, fn row -> do_intervals(row, []) end)
def do_intervals(row, acc) do
if Enum.all?(row, &Kernel.==(&1, 0)) do
[row | acc]
else
next_row = Enum.chunk_every(row, 2, 1, :discard) |> Enum.map(fn [a, b] -> b - a end)
do_intervals(next_row, [row | acc])
end
end
def apply_intervals(intervals, part \\ 1)
def apply_intervals(intervals, 1) do
intervals
|> Enum.map(&Enum.map(&1, fn row -> Enum.reverse(row) |> hd() end))
|> Enum.map(&Enum.sum/1)
end
def apply_intervals(intervals, 2) do
intervals
|> Enum.map(&Enum.map(&1, fn row -> hd(row) end))
|> Enum.map(&Enum.reduce(&1, fn i, acc -> i - acc end))
end
defmodule Part1 do
def solve(input) do
input
|> Day9.parse()
|> Day9.intervals()
|> Day9.apply_intervals()
|> Enum.sum()
end
end
defmodule Part2 do
def solve(input) do
input
|> Day9.parse()
|> Day9.intervals()
|> Day9.apply_intervals(2)
|> Enum.sum()
end
end
end
2
pehbehbeh
Built an extrapolate function with map and unfold. Could reuse it for part 2 with minimal adjustments:
https://github.com/pehbehbeh/adventofcode/blob/main/2023/09.livemd
2
Aetherus
I just can’t get rid of the impulse to solve this puzzle using Nx and linear algebra.
Here’s my new code with a lot of description about the math.
Please download it to your livebook to see the content because GitHub does not render the LaTeX parts correctly.
https://github.com/Aetherus/advent-of-code/blob/master/2023/day-09-nx.livemd
By the way, the code is fully vectorized so there’s no explicit for-loop or Enum or Stream function calls in solving the equation, except for parsing the input and building the tensors.
2
Aetherus
Found a bug in Nx.BinaryBackend.
When running Nx.LinAlg.solve(mat_x, mat_y) in a livebook when mat_y has more columns than rows, this error was raised:
#Inspect.Error<
got ArgumentError with message:
"""
errors were found at the given arguments:
* 3rd argument: out of range
"""
while inspecting:
%{
data: %Nx.BinaryBackend{
state: <<4, 0, 0, 0, 0, 0, 8, 192, 46, 33, 9, 20, 142, 152, 243, 188, 179, 255, 255, 255, 255,
255, 19, 64, 4, 0, 0, 0, 0, 0, 8, 192, 46, 33, 9, 20, 142, 152, 243, 188, 179, 255, 255, 255,
255, 255, 19, 64, ...>>
},
type: {:f, 64},
names: [nil, nil],
__struct__: Nx.Tensor,
vectorized_axes: [],
shape: {6, 7}
}
Stacktrace:
:erlang.binary_part(<<4, 0, 0, 0, 0, 0, 8, 192, 46, 33, 9, 20, 142, 152, 243, 188, 179, 255, 255, 255, 255, 255, 19, 64, 4, 0, 0, 0, 0, 0, 8, 192, 46, 33, 9, 20, 142, 152, 243, 188, 179, 255, 255, 255, 255, 255, 19, 64, 28, 0, ...>>, 0, 336)
(nx 0.6.4) lib/nx/binary_backend.ex:179: Nx.BinaryBackend.to_binary/2
(nx 0.6.4) lib/nx/binary_backend.ex:1028: Nx.BinaryBackend.inspect/2
(nx 0.6.4) lib/nx/tensor.ex:241: Inspect.Nx.Tensor.inspect/2
(elixir 1.15.7) lib/inspect/algebra.ex:348: Inspect.Algebra.to_doc/2
(elixir 1.15.7) lib/kernel.ex:2366: Kernel.inspect/2
(kino 0.12.0) lib/kino/output.ex:21: Kino.Output.inspect/2
lib/livebook/runtime/evaluator/formatter.ex:62: Livebook.Runtime.Evaluator.Formatter.to_output/1
>
There’s no error when using EXLA.Backend.
Still digging the source code of Nx.BinaryBackend trying to spot the cause of this error.
1
adamu
Sharing a year late because I just did it while waiting for 2024 Day 2, and I don’t think anyone else used Enum.uniq
def part1(histories) do
histories |> Enum.map(&walk/1) |> Enum.sum()
end
def walk(history) do
case Enum.uniq(history) do
[last] -> last
_ -> List.last(history) + walk(diff(history))
end
end
def diff([_]), do: []
def diff([a, b | rest]), do: [b - a | diff([b | rest])]
https://git.adamu.jp/adam/AdventOfCode/src/branch/main/2023/day9.exs
0