My beginner’s solution, Day 15 part 1. Lens Library

defmodule Day15 do

  def part1(input) do
    parse(input)
    |> Enum.map(&hash/1)
    |> Enum.sum
  end

  def hash(string) do
    for <<char::8 <- string>>, reduce: 0 do
      acc -> rem(17 * (acc + char), 256)
    end
  end

  def parse(raw_sequence) do
    raw_sequence
    |> remove("\n") 
    |> String.split(",")
  end
  defp remove(s, p), do: String.replace(s, p, "")

end

The problem was really straightforward on both parts for this day. Makes me sad that I got so far behind on days 12-14. I didn’t do anything clever in my solution. This thread showed me some things I had not heard of. Namely, @code-shoily introducing Aja and @exists highlighting List.keydelete and List.keymember?. I wanted the theme this year to be binary pattern matching and manipulation as much as possible, but I didn’t want to overcomplicate this one and just used the String functions mostly.

defmodule Part1 do
    def solve(input) do
      input
      |> parse()
      |> Enum.sum()
    end

    defp parse(input) do
      hasher(input, 0, [])
    end

    def hasher(<<>>, current_val, acc), do: [current_val | acc]
    def hasher(<<",", rest::binary>>, current_val, acc), do: hasher(rest, 0, [current_val | acc])
    def hasher(<<"\n", rest::binary>>, current_val, acc), do: hasher(rest, current_val, acc)

    def hasher(<<next::8, rest::binary>>, current_val, acc),
      do: hasher(rest, hash_fun(next, current_val), acc)

    def hash_fun(next, current_val), do: rem((next + current_val) * 17, 256)
  end

  defmodule Part2 do
    def solve(input) do
      input
      |> parse()
      |> Enum.map(&calc_focus_pwr/1)
      |> total_focus_pwr()
    end

    defp parse(input) do
      input
      |> String.replace("\n", "")
      |> String.split(",")
      |> Enum.map(&parse_label/1)
      |> Enum.reduce(%{}, fn ops_label, map ->
        hash_mapper(ops_label, map)
      end)
    end

    defp parse_label(label) do
      String.split(label, ~r{-|=}, include_captures: true)
    end

    defp hash_mapper([label, op, len], map) do
      [box] = Part1.hasher(label, 0, [])

      case op do
        "-" ->
          Map.update(map, box, [], fn curr ->
            Enum.reject(curr, fn lens -> match?([^label, _], lens) end)
          end)

        "=" ->
          Map.update(map, box, [[label, len]], fn curr ->
            with nil <- Enum.find_index(curr, fn [a, _b] -> a == label end) do
              [[label, len] | curr]
            else
              ndx ->
                List.replace_at(curr, ndx, [label, len])
            end
          end)
      end
    end

    defp calc_focus_pwr({box, lenses}) do
      lenses
      |> Enum.reverse()
      |> Enum.with_index(1)
      |> Enum.map(fn {[_label, lens], ndx} -> String.to_integer(lens) * ndx * (box + 1) end)
      |> Enum.sum()
    end

    defp total_focus_pwr(enum), do: Enum.sum(enum)
  end