aoc2017_day10.ex

defmodule Day10 do
  import Bitwise

  def part1(input) do
    lengths = input |> String.split(",") |> Enum.map(&String.to_integer/1)
    [first, second | _rest] = round(initial_state(), lengths).elements
    first * second
  end

  def part2(input), do:
    input |> lengths2() |> sparse_hash() |> dense_hash() |> knot_hash()

  defp lengths2(input), do:
    input |> to_charlist() |> Enum.concat([17, 31, 73, 47, 23])

  defp sparse_hash(lengths), do:
    Enum.reduce(1..64, initial_state(), fn _step, state -> round(state, lengths) end).elements

  defp dense_hash(elements), do:
    elements
    |> Stream.chunk_every(16)
    |> Stream.map(fn chunk -> Enum.reduce(chunk, 0, &(&1 ^^^ &2)) end)

  defp knot_hash(dense_hash), do:
    dense_hash |> Stream.map(&to_padded_hex/1) |> Enum.join()

  defp to_padded_hex(number), do:
    number |> Integer.to_string(16) |> String.pad_leading(2, "0") |> String.downcase()

  defp round(state, lengths), do:
    Enum.reduce(lengths, state, &step(&2, &1))

  defp initial_state(), do:
    %{elements: 0..255, size: 256, skip_size: 0, pos: 0}

  defp step(state, length) do
    %{state |
      elements: state.elements |> shift(state.pos) |> reverse(length) |> shift(state.size - state.pos),
      skip_size: state.skip_size + 1,
      pos: rem(state.pos + state.skip_size + length, state.size)
    }
  end

  defp reverse(elements, count) do
    {to_reverse, rest} = Enum.split(elements, count)
    Enum.reverse(to_reverse) ++ rest
  end

  defp shift(elements, offset) do
    {tail, front} = Enum.split(elements, offset)
    front ++ tail
  end
end

input = "14,58,0,116,179,16,1,104,2,254,167,86,255,55,122,244"
Day10.part1(input) |> IO.inspect
Day10.part2(input) |> IO.puts