Merge pull request #3 from oleg-balunenko/refactor

cmd: Implement cli to run puzzles
internal/solutions: Refactor day01 to implement Solver interface
internal/puzzle: Add Solver interface and Run solutions func

Author: obalunenko

.gitignore

@@ -10,3 +10,7 @@
 
 # Output of the go coverage tool, specifically when used with LiteIDE
 *.out
+
+.idea
+
+bin/

cmd/main.go

@@ -0,0 +1,70 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"log"
+	"os"
+	"path/filepath"
+	"strconv"
+
+	"github.com/pkg/errors"
+
+	"github.com/oleg-balunenko/advent-of-code/internal/puzzle"
+	_ "github.com/oleg-balunenko/advent-of-code/internal/solutions/day01"
+)
+
+var (
+	inputDir = flag.String(
+		"input_dir",
+		filepath.Join(os.Getenv("GOPATH"), "src", "github.com", "oleg-balunenko", "advent-of-code", "input"),
+		"Path to directory with puzzles input files")
+)
+
+func main() {
+	flag.Parse()
+
+	menu()
+}
+
+func menu() {
+	fmt.Println("Menu:")
+
+	solvers := puzzle.Solvers()
+
+	var choices = make(map[string]string, len(solvers))
+
+	for i, s := range solvers {
+		choices[strconv.Itoa(i+1)] = s
+		fmt.Printf("%d. %s \n", i+1, s)
+	}
+
+	var text string
+
+	for {
+		_, err := fmt.Scanln(&text)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		if pname, ok := choices[text]; !ok {
+			fmt.Println("wrong choice, try again")
+		} else {
+			run(pname)
+			return
+		}
+	}
+}
+
+func run(name string) {
+	s, err := puzzle.GetSolver(name)
+	if err != nil {
+		log.Fatal(errors.Wrap(err, "failed to get solver"))
+	}
+
+	input := filepath.Join(*inputDir, fmt.Sprintf("%s.txt", name))
+
+	if err := puzzle.Run(s, input); err != nil {
+		log.Fatal(errors.Wrap(err, "failed to run puzzle solver"))
+	}
+}

puzzles/1-day/testdata/input.txt input/day01.txtpuzzles/1-day/testdata/input.txt renamed to input/day01.txt

@@ -0,0 +1 @@
+1,0,0,3,1,1,2,3,1,3,4,3,1,5,0,3,2,10,1,19,2,9,19,23,2,13,23,27,1,6,27,31,2,6,31,35,2,13,35,39,1,39,10,43,2,43,13,47,1,9,47,51,1,51,13,55,1,55,13,59,2,59,13,63,1,63,6,67,2,6,67,71,1,5,71,75,2,6,75,79,1,5,79,83,2,83,6,87,1,5,87,91,1,6,91,95,2,95,6,99,1,5,99,103,1,6,103,107,1,107,2,111,1,111,5,0,99,2,14,0,0

input/day02.txt

@@ -0,0 +1,108 @@
+package puzzle
+
+import (
+	"bytes"
+	"io"
+	"io/ioutil"
+	"log"
+	"sort"
+	"sync"
+
+	"github.com/pkg/errors"
+)
+
+// Solver represents solutions for puzzles methods.
+type Solver interface {
+	Part1(input io.Reader) (string, error)
+	Part2(input io.Reader) (string, error)
+	Name() string
+}
+
+var (
+	solversMu sync.RWMutex
+	solvers   = make(map[string]Solver)
+)
+
+// Register makes a puzzle solver available by the provided name.
+// If Register is called twice with the same name or if solver is nil,
+// it panics.
+func Register(name string, solver Solver) {
+	solversMu.Lock()
+	defer solversMu.Unlock()
+
+	if solver == nil {
+		panic("puzzle: Register solver is nil")
+	}
+
+	if _, dup := solvers[name]; dup {
+		panic("puzzle: Register called twice for solver " + name)
+	}
+
+	solvers[name] = solver
+}
+
+// Solvers returns a sorted list of the names of the registered puzzle solvers.
+func Solvers() []string {
+	solversMu.RLock()
+	defer solversMu.RUnlock()
+
+	list := make([]string, 0, len(solvers))
+
+	for name := range solvers {
+		list = append(list, name)
+	}
+
+	sort.Strings(list)
+
+	return list
+}
+
+// GetSolver returns registered solver by passed puzzle name.
+func GetSolver(name string) (Solver, error) {
+	if name == "" {
+		return nil, errors.New("empty puzzle name")
+	}
+
+	solversMu.Lock()
+	defer solversMu.Unlock()
+
+	s, exist := solvers[name]
+
+	if !exist {
+		return nil, errors.Errorf("unknown puzzle name [%s]", name)
+	}
+
+	return s, nil
+}
+
+// Run uses solver of puzzle and path to input.
+func Run(solver Solver, filepath string) error {
+	var (
+		input []byte
+		res   string
+		err   error
+	)
+
+	input, err = ioutil.ReadFile(filepath)
+	if err != nil {
+		return errors.Wrap(err, "failed to open file")
+	}
+
+	log.Printf("run puzzle solver [%s]\n", solver.Name())
+
+	res, err = solver.Part1(bytes.NewBuffer(input))
+	if err != nil {
+		return errors.Wrapf(err, "failed to run Part1 for puzzle [%s]", solver.Name())
+	}
+
+	log.Printf("Part1 answer: %s \n", res)
+
+	res, err = solver.Part2(bytes.NewBuffer(input))
+	if err != nil {
+		return errors.Wrapf(err, "failed to run Part2 for puzzle [%s]", solver.Name())
+	}
+
+	log.Printf("Part2 answer: %s \n", res)
+
+	return nil
+}

internal/puzzle/solver.go

@@ -0,0 +1,136 @@
+package day01
+
+import (
+	"bufio"
+	"io"
+	"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++
+	}
+
+	close(in)
+
+	if err = scanner.Err(); err != nil {
+		return "", errors.Wrap(err, "scanner error")
+	}
+
+	for lines > 0 {
+		select {
+		case r := <-res:
+			sum += r
+		case <-done:
+			lines--
+		}
+	}
+
+	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)
+	}
+}