Just realized I had set my Github repo to private b/c the AoC dev does not want input files public and I never remember to put it in the gitignore. So almost all my previous day’s solutions are not visible. lol.

Anyway here’s day 9 for me. Not fast enough really but gets the right answer. Could probably get a speed up by updating what the max_ndx for searching for files would be in part 2 to avoid searching indices that have already been moved.

defmodule Day9 do
  @test "2333133121414131402"

  @real File.read!(__DIR__ <> "/input.txt") |> String.trim("\n")

  def run(mode) do
    data =
      mode
      |> input()
      |> parse()

    part_1(data) |> IO.inspect(label: :part_1)
    part_2(data) |> IO.inspect(label: :part_2)
  end

  defp input(:test), do: @test
  defp input(:real), do: @real
  defp input(_), do: raise("Please use :test or :real as possible modes to run.")

  defp parse(input) do
    Stream.iterate(0, &(&1 + 1))
    |> Stream.intersperse(".")
    |> Enum.zip(String.graphemes(input) |> Enum.map(&String.to_integer/1))
  end

  defp part_1(data) do
    data
    |> compact()
    |> checksum()
  end

  defp part_2(data) do
    data
    |> into_map()
    |> compact_wo_frag()
    |> checksum_2()
  end

  defp compact(blocks) do
    blocks
    |> Enum.reduce_while({[], Enum.reverse(blocks)}, fn
      {".", space}, {acc, rev_blks} ->
        {:cont, move_blocks(space, rev_blks, acc)}

      {ndx, _blks}, {acc, [{ndx, remaining} | _] = _rev_blks} ->
        {:halt, append_blocks(acc, remaining, ndx)}

      {ndx, blks}, {acc, rev_blks} ->
        {:cont, {append_blocks(acc, blks, ndx), rev_blks}}
    end)
  end

  defp into_map(blocks) do
    blocks
    |> Enum.reduce({0, %{}}, fn {ndx_or_space, blks}, {last_dskmp_ndx, diskmap} ->
      max_ndx = last_dskmp_ndx + blks

      dm =
        Map.put(diskmap, last_dskmp_ndx, {blks, ndx_or_space})

      {max_ndx, dm}
    end)
  end

  defp compact_wo_frag({max_ndx, map}) do
    do_compact_wo_frag(0, max_ndx, map, %{})
  end

  defp do_compact_wo_frag(curr, max_ndx, _, acc) when curr > max_ndx, do: acc

  defp do_compact_wo_frag(curr, max_ndx, map, acc) do
    case Map.get(map, curr) do
      nil ->
        do_compact_wo_frag(curr + 1, max_ndx, map, acc)

      {blks, "."} ->
        move_files(blks, curr, max_ndx, max_ndx, map, acc)

      {blks, n} ->
        acc =
          0..(blks - 1)
          |> Enum.reduce(acc, fn i, a -> Map.put(a, curr + i, n) end)

        do_compact_wo_frag(curr + blks, max_ndx, map, acc)
    end
  end

  defp move_files(space, curr, search_ndx, max_ndx, map, acc) when curr >= search_ndx,
    do: do_compact_wo_frag(curr + space, max_ndx, map, acc)

  defp move_files(space, curr, search_ndx, max_ndx, map, acc) do
    case Map.get(map, search_ndx) do
      nil ->
        move_files(space, curr, search_ndx - 1, max_ndx, map, acc)

      {_, "."} ->
        move_files(space, curr, search_ndx - 1, max_ndx, map, acc)

      {blks, n} when blks == space ->
        acc =
          0..(blks - 1)
          |> Enum.reduce(acc, fn i, a -> Map.put(a, curr + i, n) end)

        do_compact_wo_frag(curr + blks, max_ndx, Map.delete(map, search_ndx), acc)

      {blks, n} when blks > space ->
        move_files(space, curr, search_ndx - 1, max_ndx, map, acc)

      {blks, n} ->
        acc =
          0..(blks - 1)
          |> Enum.reduce(acc, fn i, a -> Map.put(a, curr + i, n) end)

        move_files(
          space - blks,
          curr + blks,
          search_ndx - 1,
          max_ndx,
          Map.delete(map, search_ndx),
          acc
        )
    end
  end

  defp move_blocks(0, rev_blks, acc), do: {acc, rev_blks}

  defp move_blocks(space, [{".", _} | rest], acc), do: move_blocks(space, rest, acc)

  defp move_blocks(space, [{ndx, blks} | rest], acc) when blks > space do
    {append_blocks(acc, space, ndx), [{ndx, blks - space} | rest]}
  end

  defp move_blocks(space, [{ndx, blks} | rest], acc),
    do:
      move_blocks(
        space - blks,
        rest,
        append_blocks(acc, blks, ndx)
      )

  defp append_blocks(diskmap, blocks, ndx) do
    diskmap ++ (Stream.cycle([ndx]) |> Enum.take(blocks))
  end

  defp checksum(diskmap) do
    diskmap
    |> Enum.with_index()
    |> Enum.reduce(0, fn {id, pos}, acc -> acc + id * pos end)
  end

  defp checksum_2(diskmap) do
    diskmap
    |> Enum.reduce(0, fn {ndx, val}, sum -> sum + ndx * val end)
  end
end

Day9.run(:real)