Implement 2021/day06 puzzle solution (#70)

* feat: Add spec. tests and skeleton for 2021/day06 puzzle

* feat: Register 2021/day06 solver

* tests: Update regression tests

* feat: Implement 2021/day06 part1


feat(): Implement 2021/day06 part1


feat: Implement 2021/day06 part1

* feat(2021/day06): Refactor population algorithm; Implement part2

* fix: Linter warnings

* tests: Update regression tests

Author: obalunenko

internal/puzzles/solutions/2021/day06/solution.go

@@ -0,0 +1,121 @@
+// Package day06 contains solution for https://adventofcode.com/2021/day/6 puzzle.
+package day06
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"strconv"
+	"strings"
+
+	"github.com/obalunenko/advent-of-code/internal/puzzles"
+)
+
+func init() {
+	puzzles.Register(solution{})
+}
+
+type solution struct{}
+
+func (solution) Day() string {
+	return puzzles.Day06.String()
+}
+
+func (solution) Year() string {
+	return puzzles.Year2021.String()
+}
+
+func (solution) Part1(input io.Reader) (string, error) {
+	const daysObserve = 80
+
+	return observeFishSchool(input, daysObserve)
+}
+
+func (solution) Part2(input io.Reader) (string, error) {
+	const daysObserve = 256
+
+	return observeFishSchool(input, daysObserve)
+}
+
+func observeFishSchool(input io.Reader, days int) (string, error) {
+	states, err := parseSchoolFishesStates(input)
+	if err != nil {
+		return "", fmt.Errorf("parse school fishes states: %w", err)
+	}
+
+	sch := newSchool(days)
+	sch.addElderFishes(states)
+
+	sch.populate()
+
+	fishes := sch.getFishes()
+
+	return strconv.Itoa(fishes), nil
+}
+
+func parseSchoolFishesStates(input io.Reader) ([]int, error) {
+	scanner := bufio.NewScanner(input)
+
+	var res []int
+
+	for scanner.Scan() {
+		line := scanner.Text()
+
+		states := strings.Split(line, ",")
+		for _, s := range states {
+			n, err := strconv.Atoi(s)
+			if err != nil {
+				return nil, fmt.Errorf("parse fish state: %w", err)
+			}
+
+			res = append(res, n)
+		}
+	}
+
+	if err := scanner.Err(); err != nil {
+		return nil, fmt.Errorf("scanner error: %w", err)
+	}
+
+	return res, nil
+}
+
+type school struct {
+	days   int
+	fishes map[int]int
+}
+
+func newSchool(daysToReproduce int) *school {
+	return &school{
+		days:   daysToReproduce,
+		fishes: make(map[int]int),
+	}
+}
+
+func (s *school) addElderFishes(fishes []int) {
+	for _, st := range fishes {
+		s.fishes[st]++
+	}
+}
+
+func (s *school) getFishes() int {
+	var res int
+
+	for _, f := range s.fishes {
+		res += f
+	}
+
+	return res
+}
+
+func (s *school) populate() {
+	for d := s.days; d > 0; d-- {
+		for i := 0; i <= 8; i++ {
+			s.fishes[i-1] += s.fishes[i]
+			s.fishes[i] = 0
+		}
+
+		s.fishes[8] += s.fishes[-1]
+		s.fishes[6] += s.fishes[-1]
+		s.fishes[-1] = 0
+	}
+}

internal/puzzles/solutions/2021/day06/solution_test.go

@@ -0,0 +1,97 @@
+package day06
+
+import (
+	"io"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_solution_Year(t *testing.T) {
+	var s solution
+
+	want := "2021"
+	got := s.Year()
+
+	assert.Equal(t, want, got)
+}
+
+func Test_solution_Day(t *testing.T) {
+	var s solution
+
+	want := "6"
+	got := s.Day()
+
+	assert.Equal(t, want, got)
+}
+
+func Test_solution_Part1(t *testing.T) {
+	var s solution
+
+	type args struct {
+		input io.Reader
+	}
+
+	tests := []struct {
+		name    string
+		args    args
+		want    string
+		wantErr assert.ErrorAssertionFunc
+	}{
+		{
+			name: "test example from description",
+			args: args{
+				input: strings.NewReader("3,4,3,1,2"),
+			},
+			want:    "5934",
+			wantErr: assert.NoError,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := s.Part1(tt.args.input)
+			if !tt.wantErr(t, err) {
+				return
+			}
+
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}
+
+func Test_solution_Part2(t *testing.T) {
+	var s solution
+
+	type args struct {
+		input io.Reader
+	}
+
+	tests := []struct {
+		name    string
+		args    args
+		want    string
+		wantErr assert.ErrorAssertionFunc
+	}{
+		{
+			name: "test example from description",
+			args: args{
+				input: strings.NewReader("3,4,3,1,2"),
+			},
+			want:    "26984457539",
+			wantErr: assert.NoError,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := s.Part2(tt.args.input)
+			if !tt.wantErr(t, err) {
+				return
+			}
+
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}

internal/puzzles/solutions/2021/day06/spec.md

@@ -0,0 +1,78 @@
+# --- Day 6: Lanternfish ---
+
+## --- Part One ---
+
+The sea floor is getting steeper. Maybe the sleigh keys got carried this way?
+
+A massive school of glowing lanternfish swims past. They must spawn quickly to reach such large numbers - 
+maybe exponentially quickly? You should model their growth rate to be sure.
+
+Although you know nothing about this specific species of lanternfish, you make some guesses about their attributes. 
+Surely, each lanternfish creates a new lanternfish once every 7 days.
+
+However, this process isn't necessarily synchronized between every lanternfish - one lanternfish might have 2 days 
+left until it creates another lanternfish, while another might have 4. So, you can model each fish as a single number 
+that represents the number of days until it creates a new lanternfish.
+
+Furthermore, you reason, a new lanternfish would surely need slightly longer before it's capable of producing more 
+lanternfish: two more days for its first cycle.
+
+So, suppose you have a lanternfish with an internal timer value of 3:
+
+- After one day, its internal timer would become 2.
+- After another day, its internal timer would become 1.
+- After another day, its internal timer would become 0.
+- After another day, its internal timer would reset to 6, and it would create a new lanternfish with an 
+internal timer of 8.
+- After another day, the first lanternfish would have an internal timer of 5, and the second lanternfish would have 
+an internal timer of 7.
+
+A lanternfish that creates a new fish resets its timer to 6, not 7 (because 0 is included as a valid timer value). 
+The new lanternfish starts with an internal timer of 8 and does not start counting down until the next day.
+
+Realizing what you're trying to do, the submarine automatically produces a list of the ages of several hundred nearby 
+lanternfish (your puzzle input). For example, suppose you were given the following list:
+
+```text
+3,4,3,1,2
+```
+
+This list means that the first fish has an internal timer of 3, the second fish has an internal timer of 4, 
+and so on until the fifth fish, which has an internal timer of 2. Simulating these fish over several days would 
+proceed as follows:
+
+```text
+Initial state: 3,4,3,1,2
+After  1 day:  2,3,2,0,1
+After  2 days: 1,2,1,6,0,8
+After  3 days: 0,1,0,5,6,7,8
+After  4 days: 6,0,6,4,5,6,7,8,8
+After  5 days: 5,6,5,3,4,5,6,7,7,8
+After  6 days: 4,5,4,2,3,4,5,6,6,7
+After  7 days: 3,4,3,1,2,3,4,5,5,6
+After  8 days: 2,3,2,0,1,2,3,4,4,5
+After  9 days: 1,2,1,6,0,1,2,3,3,4,8
+After 10 days: 0,1,0,5,6,0,1,2,2,3,7,8
+After 11 days: 6,0,6,4,5,6,0,1,1,2,6,7,8,8,8
+After 12 days: 5,6,5,3,4,5,6,0,0,1,5,6,7,7,7,8,8
+After 13 days: 4,5,4,2,3,4,5,6,6,0,4,5,6,6,6,7,7,8,8
+After 14 days: 3,4,3,1,2,3,4,5,5,6,3,4,5,5,5,6,6,7,7,8
+After 15 days: 2,3,2,0,1,2,3,4,4,5,2,3,4,4,4,5,5,6,6,7
+After 16 days: 1,2,1,6,0,1,2,3,3,4,1,2,3,3,3,4,4,5,5,6,8
+After 17 days: 0,1,0,5,6,0,1,2,2,3,0,1,2,2,2,3,3,4,4,5,7,8
+After 18 days: 6,0,6,4,5,6,0,1,1,2,6,0,1,1,1,2,2,3,3,4,6,7,8,8,8,8
+```
+
+Each day, a 0 becomes a 6 and adds a new 8 to the end of the list, while each other number decreases by 1 if it was 
+present at the start of the day.
+
+In this example, after 18 days, there are a total of 26 fish. After 80 days, there would be a total of 5934.
+
+Find a way to simulate lanternfish. How many lanternfish would there be after 80 days?
+
+## --- Part Two ---
+Suppose the lanternfish live forever and have unlimited food and space. Would they take over the entire ocean?
+
+After 256 days in the example above, there would be a total of 26984457539 lanternfish!
+
+How many lanternfish would there be after 256 days?

internal/puzzles/solutions/register_2021.go

@@ -14,4 +14,6 @@ import (
 	_ "github.com/obalunenko/advent-of-code/internal/puzzles/solutions/2021/day04"
 	// register day05 solution.
 	_ "github.com/obalunenko/advent-of-code/internal/puzzles/solutions/2021/day05"
+	// register day06 solution.
+	_ "github.com/obalunenko/advent-of-code/internal/puzzles/solutions/2021/day06"
 )

tests/regression_test.go

@@ -2330,10 +2330,10 @@ func testcases2021() []testcase {
 			want: puzzles.Result{
 				Year:  year,
 				Name:  puzzles.Day06.String(),
-				Part1: "",
-				Part2: "",
+				Part1: "388739",
+				Part2: "1741362314973",
 			},
-			wantErr: true,
+			wantErr: false,
 		},
 		{
 			name: "2021/day07",