I think part 2 has defeated me. Even though my code is spaghetti, part 1 was pretty easy to get right. Not sure why part 2 isn’t right.
defmodule Day14 do
@moduledoc false
@input File.read!("lib/input")
def process(version \\ 1) do
@input
|> String.split("mask = ", trim: true)
|> Enum.map(fn line -> process_line(line, version) end)
end
def process_line(line, version) do
tmp =
line
|> String.split("\n", trim: true)
mask_len = tmp |> Enum.at(0) |> String.length()
tmp
|> Enum.with_index()
|> Enum.reduce({[]}, fn {sub, ndx}, acc ->
case ndx do
0 ->
sub
|> process_mask()
|> process_helper(0, acc)
_ ->
sub
|> process_mem_assign(mask_len, version)
|> process_helper(acc)
end
end)
end
def process_mask(mask) do
mask
|> String.codepoints()
|> Enum.map(&Integer.parse(&1))
|> Enum.map(fn i ->
case i do
:error -> i
{n, _} -> n
end
end)
|> Enum.reverse()
end
def process_mem_assign(sub, mask_len, version) do
Regex.scan(~r/(?<=mem\[)\d+|(?<=]\s=\s)\d+/, sub)
|> List.flatten()
|> Enum.with_index()
|> Enum.map(fn {match, ndx} -> mem_assign_helper(match, ndx, version, mask_len) end)
|> List.to_tuple()
end
def mem_assign_helper(match, ndx, version, mask_len) do
case {version, ndx} do
{1, 0} ->
String.to_integer(match)
{1, _} ->
String.to_integer(match) |> Integer.digits(2) |> pad_list(mask_len) |> Enum.reverse()
{2, 0} ->
String.to_integer(match) |> Integer.digits(2) |> pad_list(mask_len) |> Enum.reverse()
{2, _} ->
String.to_integer(match)
end
end
def pad_list(val, len) do
1..len
|> Enum.reduce(val, fn _, acc -> [0 | acc] end)
end
def process_helper(matches, 0, acc) do
Tuple.insert_at(acc, 0, matches)
end
def process_helper(matches, {mask, assignments}) do
{mask, [matches | assignments]}
end
def initialize(version \\ 1) do
process(version)
|> build_mem_map(version)
end
def build_mem_map(processed_lines, version \\ 1) do
processed_lines
|> Enum.reduce(%{}, fn {mask, assignments}, memory ->
assign_memory(mask, assignments, memory, version)
end)
end
def assign_memory(mask, assignments, memory, version) do
assignments
|> Enum.map(&apply_mask(&1, mask, version))
|> Enum.reduce(memory, fn assign, acc -> update_memory(assign, acc, version) end)
end
def apply_mask({address, value}, mask, version) when version == 1 do
{address,
value
|> Enum.zip(mask)
|> Enum.map(fn {v, m} ->
case m do
:error -> v
_ -> m
end
end)
|> Enum.reverse()
|> Integer.undigits(2)}
end
def apply_mask({address, value}, mask, version) when version == 2 do
addresses =
address
|> Enum.zip(mask)
|> Enum.reduce([[]], fn {a, m}, acc ->
case m do
:error ->
acc |> Enum.reduce([], fn digits, coll -> [[0 | digits], [1 | digits] | coll] end)
0 ->
acc |> Enum.reduce([], fn digits, coll -> [[a | digits] | coll] end)
1 ->
acc |> Enum.reduce([], fn digits, coll -> [[1 | digits] | coll] end)
end
end)
|> Enum.map(&Enum.reverse(&1))
|> Enum.map(&Integer.undigits(&1, 2))
{addresses, value}
end
def update_memory({address, value}, memory, 1) do
Map.put(memory, address, value)
end
def update_memory({addresses, value}, memory, 2) do
addresses
|> Enum.reduce(memory, fn add, acc -> Map.put(acc, add, value) end)
end
def run do
initialize()
|> sum_memory()
|> IO.puts()
end
def run2 do
initialize(2)
|> sum_memory()
|> IO.puts()
end
def sum_memory(mem_map) do
mem_map
|> Map.values()
|> Enum.sum()
end
end
Day14.run()
Day14.run2()
