Solved with a genetic algorithm.

Easy one!
y2021/day_07.ex

Not sure if this was accidentally swapped with Day 3 or something. Way too easy.

defmodule AdventOfCode.Y2021.Day07 do
  use AdventOfCode.Helpers.InputReader, year: 2021, day: 7

  def run_1, do: input!() |> parse() |> alignments() |> Enum.min()
  def run_2, do: input!() |> parse() |> alignments(&cost/1) |> Enum.min()
  def parse(data), do: data |> String.split(",") |> Enum.map(&String.to_integer/1)

  defp alignments(positions, cost_fn \\ &Function.identity/1) do
    for i <- positions do
      Enum.sum(for j <- positions, do: cost_fn.(abs(i - j)))
    end
  end

  defp cost(steps), do: (steps == 0 && 0) || div(steps * (steps + 1), 2)
end

hey, this looks so simple, that I had to try it.
Sadly, doesn’t seem to work for my inputs. Could it be that your solution only considers positions that appear in the input file? but the minimum cost might not be one of the original positions. It might be that every submarine needs to be moved

$ elixir day_7.ex
"me"
Part 1: fuel: 342730
Part 2: position: 476
Part 2: fuel: 92335207
"code-shoily"
Part 1: fuel: 342730
Part 2: fuel: 92338199

My Day 7:

defmodule Day7 do
  def part1(input) do
    input =
      input
      |> parse()
      |> Enum.sort()

    count = Enum.count(input)
    median = Enum.at(input, div(count, 2))

    Enum.reduce(input, 0, fn elem, acc ->
      abs(elem - median) + acc
    end)
  end

  def part2(input) do
    input = parse(input)

    avg = Enum.sum(input) / Enum.count(input)

    [floor(avg), ceil(avg)]
    |> Enum.map(fn cheapest ->
      Enum.reduce(input, 0, fn elem, acc ->
        n = abs(elem - cheapest)
        acc + div(n * (n + 1), 2)
      end)
    end)
    |> Enum.min()
  end

  defp parse(input) do
    input
    |> String.split(",")
    |> Enum.map(&String.to_integer/1)
  end
end