I tried something a little different - instead of keeping track of the position of called numbers, I only keep track of the number of times a number has been called in a specific row/column. When a row or column then has 5, I know that board had a bingo.
I calculated the number of moves to win a bingo for each board, which made part two really easy. I just needed to use the Enum.min/2 or Enum.max/2 functions to determine the board that was the winner/loser.
Code below, run in LiveBook:
(edit: I was reading other methods that people used and I realize that there is a Enum.reduce_while function. That would have been helpful! Will use in the future)
defmodule Part1 do
def get_board_statistics(board, numbers) do
numbers
|> Enum.reduce({[0,0,0,0,0], [0,0,0,0,0], 0, "", false}, fn number, acc = {row_counts, col_counts, count_til_bingo, winning_number, stop} ->
unless stop do
case get_index_row_col(board, number) do
{row_index, col_index} ->
row_counts = List.update_at(row_counts, row_index, & &1 + 1)
col_counts = List.update_at(col_counts, col_index, & &1 + 1)
{row_counts, col_counts, count_til_bingo + 1, number, 5 in row_counts or 5 in col_counts}
nil ->
{row_counts, col_counts, count_til_bingo + 1, winning_number, stop}
end
else
acc
end
end)
end
defp get_index_row_col(board, number) do
row_index =
board
|> Enum.find_index(&(number in &1))
unless is_nil(row_index) do
col_index =
board
|> Enum.at(row_index)
|> Enum.find_index(&(number == &1))
{row_index, col_index}
end
end
end
inputs =
"advent/inputs/day04.txt"
|> Path.relative()
|> File.read!()
|> String.split("\n")
|> Enum.drop(-1)
[numbers | rest] = inputs
numbers = numbers |> String.trim() |> String.split(",")
boards =
rest
|> Enum.drop(1)
|> Enum.chunk_every(5, 6)
|> Enum.map(fn board ->
Enum.map(board, fn row ->
row
|> String.trim()
|> String.split(" ")
|> Enum.reject(&(&1 == ""))
end)
end)
{count_to_win, winning_number, winning_board} =
Enum.map(boards, fn board ->
{_, _, count_til_bingo, winning_number, _} = Part1.get_board_statistics(board, numbers)
{count_til_bingo, winning_number, board}
end)
|> Enum.min(fn {num1, _, _}, {num2, _, _} -> num1 < num2 end)
numbers_called = Enum.take(numbers, count_to_win)
score =
winning_board
|> List.flatten()
|> Enum.reject(& &1 in numbers_called)
|> Enum.map(&String.to_integer/1)
|> Enum.sum
|> Kernel.*(String.to_integer(winning_number))
# part 2
{count_to_lose, losing_number, losing_board} =
Enum.map(boards, fn board ->
{_, _, count_til_bingo, losing_number, _} = Part1.get_board_statistics(board, numbers)
{count_til_bingo, losing_number, board}
end)
|> Enum.max(fn {num1, _, _}, {num2, _, _} -> num1 > num2 end)
|> IO.inspect
numbers_called = Enum.take(numbers, count_to_lose)
score =
losing_board
|> List.flatten()
|> Enum.reject(& &1 in numbers_called)
|> Enum.map(&String.to_integer/1)
|> Enum.sum
|> Kernel.*(String.to_integer(losing_number))
