I solved Part I with a DynamicSupervisor and a process per a fish approach 
I expected fish behavioral features are to be changed in Part II and boom.
mudasobwa
Creator of Cure
groovyda
mexicat
It’s nice when it works on part 2 without modifications. Not the most clever solution but it’s fast enough!
defmodule AdventOfCode.Day06 do
def part1(input) do
input
|> parse_input()
|> Enum.frequencies()
|> pass_days(80)
|> Map.values()
|> Enum.sum()
end
def part2(input) do
input
|> parse_input()
|> Enum.frequencies()
|> pass_days(256)
|> Map.values()
|> Enum.sum()
end
def pass_days(fish, 0), do: fish
def pass_days(fish, days_left) do
fish
|> Enum.reduce(%{}, fn
{0, qt}, acc ->
acc |> Map.update(6, qt, &(&1 + qt)) |> Map.put(8, qt)
{n, qt}, acc ->
acc |> Map.update(n - 1, qt, &(&1 + qt))
end)
|> pass_days(days_left - 1)
end
def parse_input(input) do
input |> String.trim() |> String.split(",") |> Enum.map(&String.to_integer/1)
end
end
1
deadbeef
My solution:
I used 2 maps to track two groups of fish. fish cycles 7 days, spawn cycles 9 days.
I couldn’t figure a way to track of all fish at the same rate, so I split into two groups, each with a different “gestation” rate.
Runs ~250ms on Apple M1.
defmodule Advent.Y2021.D06 do
@spec part_one([integer()], integer()) :: integer()
def part_one(seed, days) do
map_solution(seed, days)
end
@spec part_two([integer()], integer()) :: integer()
def part_two(seed, days) do
map_solution(seed, days)
end
defp map_solution(seed, days) do
fish = Enum.frequencies(seed)
Stream.unfold({0, fish, %{}}, fn
{day, fish, spawn} ->
fish_cycle = rem(day, 7)
spawn_cycle = rem(day, 9)
num_new_fish = Map.get(spawn, spawn_cycle, 0)
fish = Map.update(fish, fish_cycle, num_new_fish, &(&1 + num_new_fish))
spawn = Map.put(spawn, spawn_cycle, Map.fetch!(fish, fish_cycle))
{{fish, spawn}, {day + 1, fish, spawn}}
end)
|> Enum.at(days - 1)
|> (fn {fish, spawn} ->
Map.merge(fish, spawn, fn _k, v1, v2 -> v1 + v2 end)
end).()
|> Map.values()
|> Enum.sum()
end
end
input =
Path.join(["d06_input.txt"])
|> File.stream!()
|> Stream.map(&String.trim/1)
|> Enum.at(0)
|> String.split(",")
|> Enum.map(&String.to_integer/1)
IO.inspect(Advent.Y2021.D06.part_one(input, 80))
IO.inspect(Advent.Y2021.D06.part_two(input, 256))
I originally had a function list_solution/2 I used for part one. It took way too long for part two (I killed attempt before completion). But here it is incase there’s any interest
@spec list_solution([integer()], integer()) :: integer()
defp list_solution(seed, days) do
Stream.iterate(seed, fn fish ->
num_spawning_fish = Enum.count(fish, &(&1 == 0))
fish =
Enum.map(fish, fn
0 -> 6
n -> n - 1
end)
fish ++ List.duplicate(8, num_spawning_fish)
end)
|> Enum.at(days)
|> length()
end
0
deadbeef
Looking at others, I see that updating the map key isn’t expensive, and performance is similar - probably the cleaner/nicer way to go!
0
egze
stefanluptak
Eh, one of the more difficult days for me.
It was immediately clear to me that recursion with big lists is not the way to solve this.
But I was not able to realize that Enum.frequencies is the key to this. Quite frustrating, once again. 
I had to take a peek here. Once I saw it mentioned, it was so obvious.
day_06.livemd
1
Klohto
Looking at the replies, nothing special with my solution. Frequencies and updates. Just that I used reduce.
Enum.reduce(1..256, start_state, fn _, state ->
state
|> Enum.reduce(%{}, fn
{0, c}, curr_state ->
curr_state |> Map.update(6, c, &(c + &1)) |> Map.update(8, c, &(c + &1))
{age, c}, curr_state ->
curr_state |> Map.update(age - 1, c, &(c + &1))
end)
end)
|> Map.values()
|> Enum.sum()
Full Livebook https://github.com/Klohto/AdventOfCode/blob/main/2021/day6.livemd
2