Here’s mine solution: https://github.com/pozhega/AoC/blob/master/lib/aoc/Y2019/d2.ex
pozhega
keathley
Mine: https://github.com/keathley/advent_of_code_2019/blob/master/day2.exs.
I did something similar to @sasajuric on part 2 using the pattern of generating all possible VMs as a stream and then using Enum.find to get the one that you want: https://github.com/keathley/advent_of_code_2019/blob/master/day2.exs#L66-L74.
That’s one of my favorite patterns in elixir.
2
NobbZ
egze
Cool. Let’s make this the official one? 
@bjorng Could you include it in your posts please? Here is the link to join a private leaderboard: Log In - Advent of Code 2019
2
alvises
Just had time to finish mine: aoc2019/lib/aoc2019/day2.ex at master · alvises/aoc2019 · GitHub
I had refactored it a bit after seeing @sasajuric solution, liked the comprehension + Enum.find. In my first version I did it with an excessively complicated Stream.iteration + Enum.reduce_while.
Guys, weren’t the first two days of the aoc2018 much easier? The first day was just a sum of nums if I remember correctly… I’m curious to see what they come out increasing the difficulty 
What the score is based on? (just joined, I hope is fine )
0
sasajuric
Author of Elixir In Action
It’s not all that difficult to also generate permutations lazily:
0..99
|> Stream.flat_map(fn noun -> Stream.map(0..99, &{noun, &1}) end)
My first version used this approach, but then I decided to switch to for b/c I think it communicates the intention a bit better.
4
NobbZ
We have n users in the group, so a star is up to n points worth.
The mth person that gets a star will receive n-m+1 points, as there are 2 stars per day, max score per day is 2 * n.
So full score for the first person, one point less for the second, etc.
2
keathley
Yeah for sure. I didn’t spend much time optimizing since its still a pretty low set of inputs and the algorithm is O(n).
0
hauleth
My solution:
defmodule GravAssist do
def calc([op, _, _ | rest], a \\ 12, b \\ 2) do
hd(execute([op, a, b | rest]))
end
def execute(bytecode) when is_list(bytecode), do: execute(:array.from_list(bytecode))
def execute(bytecode), do: eval(bytecode, 0)
defp eval(bytecode, ic) do
case :array.get(ic, bytecode) do
99 -> :array.to_list(bytecode)
op when op in 1..2 ->
pos_a = :array.get(ic + 1, bytecode)
pos_b = :array.get(ic + 2, bytecode)
pos_r = :array.get(ic + 3, bytecode)
result = compute(op, :array.get(pos_a, bytecode), :array.get(pos_b, bytecode))
new_bc = :array.set(pos_r, result, bytecode)
eval(new_bc, ic + 4)
_ -> :error
end
end
defp compute(1, a, b), do: a + b
defp compute(2, a, b), do: a * b
end
data =
IO.read(:line)
|> String.split(",")
|> Enum.map(&String.to_integer(String.trim(&1)))
IO.inspect(GravAssist.calc(data), label: :sol1)
for(a <- 0..99,
b <- 0..99,
19690720 == GravAssist.calc(data, a, b),
do: {a, b})
|> IO.inspect(label: :sol2)
3
bjorng
Erlang Core Team