internal/solutions: Refactor day01 to implement Solver interface

Author: obalunenko

internal/solutions/day01/fuel.go

@@ -0,0 +1,140 @@
+package day01
+
+import (
+	"bufio"
+	"io"
+	"log"
+	"strconv"
+
+	"github.com/pkg/errors"
+
+	"github.com/oleg-balunenko/advent-of-code/internal/puzzle"
+)
+
+type solver struct {
+	name string
+}
+
+func init() {
+	const puzzleName = "day01"
+
+	puzzle.Register(puzzleName, solver{
+		name: puzzleName,
+	})
+}
+
+func (s solver) Part1(input io.Reader) (string, error) {
+	return calc(input, calcPart1)
+}
+
+func (s solver) Part2(input io.Reader) (string, error) {
+	return calc(input, calcPart2)
+}
+
+func (s solver) Name() string {
+	return s.name
+}
+
+type module struct {
+	mass int
+}
+
+func (m module) fuel() int {
+	mass := m.mass
+
+	diff := mass % 3
+	if diff != 0 {
+		mass = mass - diff
+	}
+
+	f := (mass / 3) - 2
+
+	return f
+}
+
+type calcFunc func(in chan module, res chan int, done chan struct{})
+
+func calc(input io.Reader, calcFn calcFunc) (string, error) {
+	var (
+		lines int
+		mass  int
+		sum   int
+		err   error
+	)
+
+	in := make(chan module)
+	res := make(chan int)
+	done := make(chan struct{})
+
+	go calcFn(in, res, done)
+
+	scanner := bufio.NewScanner(input)
+
+	for scanner.Scan() {
+		mass, err = strconv.Atoi(scanner.Text())
+		if err != nil {
+			return "", err
+		}
+
+		in <- module{
+			mass: mass,
+		}
+		lines++
+	}
+	log.Printf("lines: %d\n", lines)
+
+	close(in)
+
+	if err = scanner.Err(); err != nil {
+		return "", errors.Wrap(err, "scanner error")
+	}
+	var resNumCount int
+	for lines > 0 {
+		select {
+		case r := <-res:
+			sum += r
+			resNumCount++
+		case <-done:
+			lines--
+		}
+	}
+	log.Printf("res count: %d \n", resNumCount)
+
+	close(res)
+
+	return strconv.Itoa(sum), nil
+}
+
+func calcPart1(in chan module, res chan int, done chan struct{}) {
+	for i := range in {
+		go func(m module, res chan int, done chan struct{}) {
+			f := m.fuel()
+
+			res <- f
+
+			done <- struct{}{}
+		}(i, res, done)
+	}
+}
+
+func calcPart2(in chan module, res chan int, done chan struct{}) {
+	for i := range in {
+		go func(m module, res chan int, done chan struct{}) {
+			var isDone bool
+
+			for !isDone {
+				f := m.fuel()
+
+				res <- f
+
+				if f/3 > 1 {
+					m.mass = f
+				} else {
+					isDone = true
+				}
+			}
+
+			done <- struct{}{}
+		}(i, res, done)
+	}
+}

internal/solutions/day01/fuel_test.go

@@ -0,0 +1,175 @@
+package day01
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_module_fuel(t *testing.T) {
+	type fields struct {
+		mass int
+	}
+
+	tests := []struct {
+		name   string
+		fields fields
+		want   int
+	}{
+		{
+			name: "mass 12",
+			fields: fields{
+				mass: 12,
+			},
+			want: 2,
+		},
+		{
+			name: "mass 14",
+			fields: fields{
+				mass: 14,
+			},
+			want: 2,
+		},
+		{
+			name: "mass 1969",
+			fields: fields{
+				mass: 1969,
+			},
+			want: 654,
+		},
+		{
+			name: "mass 100756",
+			fields: fields{
+				mass: 100756,
+			},
+			want: 33583,
+		},
+	}
+
+	for _, tt := range tests {
+		tt := tt
+
+		t.Run(tt.name, func(t *testing.T) {
+			m := module{
+				mass: tt.fields.mass,
+			}
+
+			got := m.fuel()
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}
+
+func Test_calcPart1(t *testing.T) {
+	in := make(chan module)
+	res := make(chan int)
+	done := make(chan struct{})
+
+	go calcPart1(in, res, done)
+
+	tests := []struct {
+		name  string
+		input int
+		want  int
+	}{
+		{
+			name:  "mass 12",
+			input: 12,
+			want:  2,
+		},
+		{
+			name:  "mass 14",
+			input: 14,
+			want:  2,
+		},
+		{
+			name:  "mass 1969",
+			input: 1969,
+			want:  654,
+		},
+		{
+			name:  "mass 100756",
+			input: 100756,
+			want:  33583,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			in <- module{mass: tt.input}
+
+			var got int
+
+		LOOP:
+			for {
+				select {
+				case r := <-res:
+					got += r
+				case <-done:
+					break LOOP
+				}
+			}
+
+			assert.Equal(t, tt.want, got)
+		})
+	}
+
+	close(in)
+}
+
+func Test_calcPart2(t *testing.T) {
+	in := make(chan module)
+	res := make(chan int)
+	done := make(chan struct{})
+
+	go calcPart2(in, res, done)
+
+	tests := []struct {
+		name  string
+		input int
+		want  int
+	}{
+		{
+			name:  "mass 12",
+			input: 12,
+			want:  2,
+		},
+		{
+			name:  "mass 14",
+			input: 14,
+			want:  2,
+		},
+		{
+			name:  "mass 1969",
+			input: 1969,
+			want:  966,
+		},
+		{
+			name:  "mass 100756",
+			input: 100756,
+			want:  50346,
+		},
+	}
+	for _, tt := range tests {
+		tt := tt
+
+		t.Run(tt.name, func(t *testing.T) {
+			in <- module{mass: tt.input}
+
+			var got int
+
+		LOOP:
+			for {
+				select {
+				case r := <-res:
+					got += r
+				case <-done:
+					break LOOP
+				}
+			}
+
+			assert.Equal(t, tt.want, got)
+		})
+	}
+
+	close(in)
+}