Advent of Code 2021 - Day 6

Here is my solution:

https://github.com/bjorng/advent-of-code-2021/blob/2605f7079c9cb7350daa5ba7cc13a84dd3e439b7/day06/lib/day06.ex

https://github.com/rugyoga/aoc2021/blob/main/day6.exs

I went with representing the frequencies as a tuple and a simulation step was:

defp simulate({s0, s1, s2, s3, s4, s5, s6, s7, s8}, days) when days > 0 do
  simulate({s1, s2, s3, s4, s5, s6, s7 + s0, s8, s0}, days - 1)
end

Full solution

It’d be nice to see an Nx solution here, it fits this problem very nicely.

https://github.com/princemaple/aoc/blob/main/2021/day6.exs

I did it the “slow” way the first time and got instant gratification, the later part, not so instant (in fact not all) until I remembered bucket sort and my good old friends Enum.frequencies and Map.merge/3

Here’s how the end product looked like:

defmodule AdventOfCode.Y2021.Day06 do
  use AdventOfCode.Helpers.InputReader, year: 2021, day: 6

  def run_1, do: input!() |> parse() |> multiply(80) |> Enum.sum()
  def run_2, do: input!() |> parse() |> multiply(256) |> Enum.sum()
  def parse(f), do: f |> String.split(",") |> Enum.map(&String.to_integer/1) |> Enum.frequencies()

  def multiply(fishes, day) do
    (day == 0 && Map.values(fishes)) ||
      multiply(
        Map.pop(fishes, 0)
        |> then(
          &Map.merge(
            for({k, v} <- elem(&1, 1), into: %{}, do: {k - 1, v}),
            %{6 => elem(&1, 0) || 0, 8 => elem(&1, 0) || 0},
            fn _, a, b -> a + b end
          )
        ),
        day - 1
      )
  end
end

struggling with the size of part 2. I want to do this in a mathematical way following an exponential growth equation like number of fishes * (1 + rate of growth)^number of days but this doesn’t work.

I enjoyed this one!

defmodule Aoc.Y2021.Day06 do
  @moduledoc """
  Solved https://adventofcode.com/2021/day/6
  """
  import Aoc.Helper.IO

  def run_part1(), do: get_input() |> solve_part1()
  def run_part2(), do: get_input() |> solve_part2()

  def solve_part1(data), do: solve(data, 80)
  def solve_part2(data), do: solve(data, 256)

  def solve(data, days), do: data |> fish_count() |> simulate(days) |> Enum.sum()
  def fish_count(data), do: Enum.map(0..8, fn n -> Map.get(Enum.frequencies(data), n, 0) end)

  def simulate(fish_count, 0), do: fish_count

  def simulate([zeroth, first, second, third, fourth, fifth, sixth, seventh, eighth], days) do
    simulate([first, second, third, fourth, fifth, sixth, seventh + zeroth, eighth, zeroth], days - 1)
  end

  defp get_input(), do: get_integer_input("2021", "06", ",")
end

I wish I analyzed input properties more before jumping to solving things. The same happened with Bingo, the solution looked different in my head before and after I realized it’s a 5x5 grid all the time.

Looking forward to what you come up with. I was thinking the same thing but got lazy (scared) and backed away.

I’m going to have to go to bed without solving it. My initial idea was Bn= B0 x 2^Kt where B0 is the original count for each timer value. K is 1/7 and t (for part 2) is 256 - the original timer value. Just calculate that for each original timer value and then add them together. Not sure how to make it work though.

DERP.
Not accounting for the maturation time with each generation.