Implement 2021/day07 puzzle solution (#73)

* feat(2021/day07): Add spec and tests

* tests(2021/day07): Update regression tests

* feat(2021/day07): Add negative tests

* feat: Implement parse ints utils function

* feat(2021/day07): Implement part1

* feat(2021/day07): Register solver

* tests: Add regression tests for 2021/day07 part1

* feat(2021/day07): Part 2 implementation

* feat(2021/day07): Add fixme

* feat(2021/day07): Implement part 2

* tests: Add regression tests

* refactor: Fix wcl linter warnings

* refactor: Remove not needed code

* tests: Improve test coverage

* tests: Add edge case test

Author: obalunenko

internal/puzzles/common/utils/parse.go

@@ -0,0 +1,46 @@
+package utils
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"strconv"
+	"strings"
+)
+
+// ParseInts parses io.Reader into []int.
+func ParseInts(in io.Reader, sep string) ([]int, error) {
+	scanner := bufio.NewScanner(in)
+
+	var res []int
+
+	for scanner.Scan() {
+		line := scanner.Text()
+
+		if sep == "" {
+			n, err := strconv.Atoi(line)
+			if err != nil {
+				return nil, fmt.Errorf("parse int: %w", err)
+			}
+
+			res = append(res, n)
+		} else {
+			split := strings.Split(line, sep)
+
+			for _, s := range split {
+				n, err := strconv.Atoi(s)
+				if err != nil {
+					return nil, fmt.Errorf("parse int: %w", err)
+				}
+
+				res = append(res, n)
+			}
+		}
+	}
+
+	if err := scanner.Err(); err != nil {
+		return nil, fmt.Errorf("scanner error: %w", err)
+	}
+
+	return res, nil
+}

internal/puzzles/common/utils/parse_test.go

@@ -0,0 +1,91 @@
+package utils
+
+import (
+	"errors"
+	"io"
+	"strings"
+	"testing"
+	"testing/iotest"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestParseInts(t *testing.T) {
+	type args struct {
+		in  io.Reader
+		sep string
+	}
+
+	tests := []struct {
+		name    string
+		args    args
+		want    []int
+		wantErr assert.ErrorAssertionFunc
+	}{
+		{
+			name: "",
+			args: args{
+				in:  strings.NewReader("1,2,3,4,5"),
+				sep: ",",
+			},
+			want:    []int{1, 2, 3, 4, 5},
+			wantErr: assert.NoError,
+		},
+		{
+			name: "",
+			args: args{
+				in:  strings.NewReader("1\n2\n3\n4\n5"),
+				sep: "",
+			},
+			want:    []int{1, 2, 3, 4, 5},
+			wantErr: assert.NoError,
+		},
+		{
+			name: "",
+			args: args{
+				in:  strings.NewReader("1,2\n3,4\n5"),
+				sep: ",",
+			},
+			want:    []int{1, 2, 3, 4, 5},
+			wantErr: assert.NoError,
+		},
+		{
+			name: "",
+			args: args{
+				in:  iotest.ErrReader(errors.New("custom error")),
+				sep: ",",
+			},
+			want:    nil,
+			wantErr: assert.Error,
+		},
+		{
+			name: "broken int",
+			args: args{
+				in:  strings.NewReader("1s,2\n3,4\n5"),
+				sep: ",",
+			},
+			want:    nil,
+			wantErr: assert.Error,
+		},
+		{
+			name: "broken int",
+			args: args{
+				in:  strings.NewReader("1,\n2\n3\n4\n5"),
+				sep: "",
+			},
+			want:    nil,
+			wantErr: assert.Error,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := ParseInts(tt.args.in, tt.args.sep)
+			if !tt.wantErr(t, err) {
+				return
+			}
+
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}

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

@@ -0,0 +1,189 @@
+// Package day07 contains solution for https://adventofcode.com/2021/day/7 puzzle.
+package day07
+
+import (
+	"fmt"
+	"io"
+	"sort"
+	"strconv"
+
+	"github.com/obalunenko/advent-of-code/internal/puzzles"
+	"github.com/obalunenko/advent-of-code/internal/puzzles/common/utils"
+)
+
+func init() {
+	puzzles.Register(solution{})
+}
+
+type solution struct{}
+
+func (solution) Day() string {
+	return puzzles.Day07.String()
+}
+
+func (solution) Year() string {
+	return puzzles.Year2021.String()
+}
+
+func (solution) Part1(input io.Reader) (string, error) {
+	crabs, err := getCrabs(input)
+	if err != nil {
+		return "", fmt.Errorf("get crabs: %w", err)
+	}
+
+	s := makeSwarm(crabs)
+
+	s.calcDistances(part1Cost)
+
+	cost := s.minDistanceCost()
+
+	return strconv.Itoa(cost), nil
+}
+
+func (solution) Part2(input io.Reader) (string, error) {
+	crabs, err := getCrabs(input)
+	if err != nil {
+		return "", fmt.Errorf("get crabs: %w", err)
+	}
+
+	s := makeSwarm(crabs)
+
+	s.calcDistances(part2Cost)
+
+	cost := s.minDistanceCost()
+
+	return strconv.Itoa(cost), nil
+}
+
+func getCrabs(input io.Reader) ([]int, error) {
+	crabs, err := utils.ParseInts(input, ",")
+	if err != nil {
+		return nil, fmt.Errorf("parse int slice from reader: %w", err)
+	}
+
+	return crabs, nil
+}
+
+const (
+	undef = -99999
+)
+
+func makeMatrix(crabs []int) [][]int {
+	const (
+		header = 1
+	)
+
+	sort.Ints(crabs)
+
+	cnum := len(crabs)
+
+	max := crabs[cnum-1]
+
+	matrix := make([][]int, cnum+header)
+
+	// matrix[i][j].
+	// 	i - crabs; j - all positions from 0 to max
+	for i := 0; i < cnum+header; i++ {
+		matrix[i] = make([]int, max+header+1)
+
+		if i == 0 {
+			matrix[i][0] = undef
+
+			for j := 1; j <= max+header; j++ {
+				matrix[i][j] = j - 1
+			}
+
+			continue
+		}
+
+		matrix[i][0] = crabs[i-1]
+	}
+
+	return matrix
+}
+
+type swarm struct {
+	crabsNum     int
+	distancesNum int
+	crabsMatrix  [][]int
+}
+
+func (s swarm) getMatrixILen() int {
+	return s.crabsNum + 1
+}
+
+func (s swarm) getMatrixJLen() int {
+	return s.distancesNum + 1
+}
+
+func makeSwarm(crabs []int) swarm {
+	matrix := makeMatrix(crabs)
+
+	crabsNum := len(matrix)
+
+	distNum := len(matrix[0])
+
+	return swarm{
+		crabsNum:     crabsNum - 1,
+		distancesNum: distNum - 1,
+		crabsMatrix:  matrix,
+	}
+}
+
+type fuelCostFunc func(p int) int
+
+func part1Cost(p int) int {
+	return p
+}
+
+func part2Cost(p int) int {
+	// formula a_{n}=a_{1}+(n-1)d
+	an := 1 + 1*(p-1)
+
+	// formula s_{n}=(a_{1}+a_{n})/2*n
+	s := ((1 + an) * p) / 2
+
+	return s
+}
+
+func (s *swarm) calcDistances(cost fuelCostFunc) {
+	for i := 1; i < s.getMatrixILen(); i++ {
+		for j := 1; j < s.getMatrixJLen(); j++ {
+			p := s.crabsMatrix[i][0] - s.crabsMatrix[0][j]
+			if p < 0 {
+				p *= -1
+			}
+
+			s.crabsMatrix[i][j] = cost(p)
+		}
+	}
+}
+
+func (s swarm) minDistanceCost() int {
+	return minDistanceCost(s.crabsMatrix)
+}
+
+func minDistanceCost(matrix [][]int) int {
+	var min int
+
+	ilen := len(matrix)
+	jlen := len(matrix[0])
+
+	for j := 1; j < jlen; j++ {
+		var f int
+
+		for i := 1; i < ilen; i++ {
+			f += matrix[i][j]
+		}
+
+		if j == 1 {
+			min = f
+		}
+
+		if f < min {
+			min = f
+		}
+	}
+
+	return min
+}