I’ve only done part 1 and realized I was trying to be too clever and have to redo the whole thing for part 2. I thought I would be able to basically do a single pass by pattern matching on binaries but it didn’t work out and I just wanted to get an answer.
defmodule Day14 do
@moduledoc """
Day14 AoC Solutions
"""
alias AocToolbox.Input
def input(:test),
do: """
O....#....
O.OO#....#
.....##...
OO.#O....O
.O.....O#.
O.#..O.#.#
..O..#O..O
.......O..
#....###..
#OO..#....
"""
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
defmodule Part1 do
def solve(input) do
{rock_map, _, max_cols, max_rows} = parse(input)
IO.inspect({max_cols, max_rows})
0..(max_cols - 1)
|> Enum.reduce(rock_map, fn col, r_m ->
case Map.get(r_m, col) do
nil -> r_m
cells -> Map.put(r_m, col, roll_rocks(cells))
end
end)
|> Enum.reduce(0, fn {k, bin}, sum -> sum_bin(bin, max_rows) + sum end)
end
defp sum_bin(bin, max_row, acc \\ 0)
defp sum_bin(<<>>, _, acc), do: acc |> IO.inspect()
defp sum_bin(<<row::8, 1::8, rest::binary>>, max_row, acc),
do: sum_bin(rest, max_row, acc + max_row - row)
defp sum_bin(<<_row::8, 0::8, rest::binary>>, max_row, acc), do: sum_bin(rest, max_row, acc)
defp roll_rocks(column, roll_to \\ nil, acc \\ <<>>)
defp roll_rocks(<<>>, _, acc), do: acc
# no more rocks, if this one can roll it rolls all the way to the to
defp roll_rocks(<<row::8, roller?::8>>, nil, acc) when roller? == 1,
do: <<acc::binary, 0, roller?>>
defp roll_rocks(<<row::8, roller?::8>>, roll_to, acc) when roller? == 1,
do: <<acc::binary, 1 + roll_to, roller?>>
# no more rocks but this one cannot roll so it stays put
defp roll_rocks(<<row::8, roller?::8>>, _, acc), do: <<acc::binary, row, roller?>>
# top remaining rock can roll up to last rock
defp roll_rocks(<<_row::8, roller?::8, rest::binary>>, nil, acc)
when roller? == 1,
do: roll_rocks(rest, 0, <<acc::binary, 0::8, roller?::8>>)
defp roll_rocks(<<_row::8, roller?::8, rest::binary>>, roll_to, acc)
when roller? == 1,
do: roll_rocks(rest, 1 + roll_to, <<acc::binary, 1 + roll_to::8, roller?::8>>)
# top remaining rock cannot roll so becomes the next blocker
defp roll_rocks(<<row::8, 0::8, rest::binary>>, _, acc),
do: roll_rocks(rest, row, <<acc::binary, row::8, 0::8>>)
def parse(input) do
input
|> String.graphemes()
|> Enum.reduce({%{}, 0, 0, 0}, fn g, {acc, column, max_column, row} ->
case g do
"." ->
{acc, column + 1, max_column, row}
"O" ->
{Map.update(acc, column, <<row, 1>>, fn curr -> <<curr::binary, row, 1>> end),
column + 1, max_column, row}
"#" ->
{Map.update(acc, column, <<row, 0>>, fn curr -> <<curr::binary, row, 0>> end),
column + 1, max_column, row}
"\n" ->
{acc, 0, max(max_column, column), row + 1}
end
end)
end
end
end
