aoc2017_day8.ex

defmodule Day8 do
  def part1(), do:
    instructions()
    |> register_states()
    |> last()
    |> Map.values()
    |> Enum.max()

  def part2(), do:
    instructions()
    |> register_states()
    |> Stream.map(&Enum.max(Map.values(&1)))
    |> Enum.max()

  defp last(enumerable), do:
    Enum.reduce(enumerable, nil, fn registers, _ -> registers end)

  defp instructions(), do:
    "input.txt"
    |> File.stream!()
    |> Stream.map(&String.trim/1)
    |> Stream.map(&compile_instruction/1)

  defp compile_instruction(instruction_string) do
    [operation_string, condition_string] = String.split(instruction_string, ~r/\s+if\s+/)
    %{
      operation: decode(String.split(operation_string, ~r/\s/)),
      condition: decode(String.split(condition_string, ~r/\s/))
    }
  end

  defp decode([register, operator, value]), do:
    %{register: register, operator: parse_operator(operator), value: String.to_integer(value)}

  defp parse_operator("inc"), do: :+
  defp parse_operator("dec"), do: :-
  defp parse_operator(other), do: String.to_existing_atom(other)

  defp register_states(instructions), do:
    Stream.scan(instructions, %{}, &apply_instruction(&2, &1))

  defp apply_instruction(registers, %{condition: condition, operation: operation}) do
    if interpret(registers, condition),
      do: put_register(registers, operation.register, interpret(registers, operation)),
      else: registers
  end

  defp get_register(registers, name), do:
    Map.get(registers, name, 0)

  defp put_register(registers, name, value), do:
    Map.put(registers, name, value)

  defp interpret(registers, instruction), do:
    interpret(instruction.operator, get_register(registers, instruction.register), instruction.value)

  for operator <- [:+, :-, :<, :<=, :>, :>=, :==, :!=] do
    defp interpret(unquote(operator), a, b), do: Kernel.unquote(operator)(a, b)
  end
end

Day8.part1() |> IO.inspect
Day8.part2() |> IO.inspect