feat(2016/day01): Implement part2

Author: obalunenko

internal/puzzles/solutions/2016/day01/solution.go

@@ -8,6 +8,7 @@ import (
 	"regexp"
 	"strconv"
 	"strings"
+	"sync"
 
 	"github.com/obalunenko/advent-of-code/internal/puzzles"
 )
@@ -45,6 +46,10 @@ func (s solution) Part1(input io.Reader) (string, error) {
 
 	c := newCab()
 
+	go func() {
+		c.n.start()
+	}()
+
 	cmds := strings.Split(buf.String(), ", ")
 	for _, cmd := range cmds {
 		t, s, err := splitCommand(cmd)
@@ -57,13 +62,46 @@ func (s solution) Part1(input io.Reader) (string, error) {
 		}
 	}
 
-	l := c.Pos().manhattan()
+	c.n.stop()
+
+	l := c.n.Pos().manhattan()
 
 	return strconv.Itoa(l), nil
 }
 
 func (s solution) Part2(input io.Reader) (string, error) {
-	return "", puzzles.ErrNotImplemented
+	buf := new(bytes.Buffer)
+	if _, err := buf.ReadFrom(input); err != nil {
+		return "", fmt.Errorf("failed to read input: %w", err)
+	}
+
+	c := newCab()
+
+	go c.n.start()
+
+	cmds := strings.Split(buf.String(), ", ")
+	for _, cmd := range cmds {
+		t, s, err := splitCommand(cmd)
+		if err != nil {
+			return "", fmt.Errorf("split command: %w", err)
+		}
+
+		if err = c.Move(t, s); err != nil {
+			return "", fmt.Errorf("move: %w", err)
+		}
+	}
+
+	c.n.stop()
+
+	rl := c.n.revisitedList()
+	if len(rl) == 0 {
+		return "", errors.New("no revisited points")
+	}
+
+	// get first
+	l := rl[0].manhattan()
+
+	return strconv.Itoa(l), nil
 }
 
 type turn string
@@ -73,14 +111,16 @@ const (
 	rightTurn = "R"
 )
 
-func tunrFromstring(s string) (turn, error) {
+var errInvalidTurn = errors.New("invalid turn value")
+
+func turnFromstring(s string) (turn, error) {
 	switch s {
 	case leftTurn:
 		return leftTurn, nil
 	case rightTurn:
 		return rightTurn, nil
 	default:
-		return "", errors.New("invalid turn value")
+		return "", errInvalidTurn
 	}
 }
 
@@ -156,41 +196,92 @@ func (d direction) strikeTo(t turn) direction {
 }
 
 type cab struct {
-	pos    position
 	curDir direction
+	n      navigator
 }
 
 func newCab() cab {
 	return cab{
-		pos: position{
-			x: 0,
-			y: 0,
-		},
 		curDir: northDirection,
+		n:      newNavigator(),
 	}
 }
+
+var errInvalidDirect = errors.New("invalid direction")
+
+const (
+	step = 1
+)
+
 func (c *cab) Move(t turn, steps int) error {
 	c.curDir = c.curDir.strikeTo(t)
 	if !c.curDir.isValid() {
-		return errors.New("invalid direction")
+		return errInvalidDirect
 	}
 
 	switch c.curDir {
 	case northDirection:
-		c.pos.addY(steps)
+		c.n.moveNorth(steps)
 	case eastDirection:
-		c.pos.addX(steps)
+		c.n.moveEast(steps)
 	case southDirection:
-		c.pos.subY(steps)
+		c.n.moveSouth(steps)
 	case westDirection:
-		c.pos.subX(steps)
+		c.n.moveWest(steps)
 	}
 
 	return nil
 }
 
-func (c cab) Pos() position {
-	return c.pos
+func (n *navigator) moveNorth(steps int) {
+	for i := 0; i < steps; i++ {
+		n.mu.Lock()
+		n.pos.addY(step)
+		n.mu.Unlock()
+
+		n.record <- n.Pos()
+	}
+}
+
+func (n *navigator) moveEast(steps int) {
+	for i := 0; i < steps; i++ {
+		n.mu.Lock()
+		n.pos.addX(step)
+		n.mu.Unlock()
+
+		n.record <- n.Pos()
+	}
+}
+
+func (n *navigator) moveSouth(steps int) {
+	for i := 0; i < steps; i++ {
+		n.mu.Lock()
+		n.pos.subY(step)
+		n.mu.Unlock()
+
+		n.record <- n.Pos()
+	}
+}
+
+func (n *navigator) moveWest(steps int) {
+	for i := 0; i < steps; i++ {
+		n.mu.Lock()
+		n.pos.subX(step)
+		n.mu.Unlock()
+
+		n.record <- n.Pos()
+	}
+}
+
+func (c *cab) Track() track {
+	return c.n.track
+}
+
+func (n navigator) Pos() position {
+	n.mu.Lock()
+	defer n.mu.Unlock()
+
+	return n.pos
 }
 
 // Example: L4, R5
@@ -204,20 +295,93 @@ const (
 	totalMatchesNum = 3
 )
 
+var errInvalidCMD = errors.New("invalid command")
+
 func splitCommand(cmd string) (turn, int, error) {
 	parts := re.FindStringSubmatch(cmd)
 	if len(parts) != totalMatchesNum {
-		return "", 0, errors.New("invalid command")
+		return "", 0, errInvalidCMD
 	}
 
-	t, err := tunrFromstring(parts[turnPos])
+	t, err := turnFromstring(parts[turnPos])
 	if err != nil {
-		return "", 0, errors.New("invalid turn")
+		return "", 0, fmt.Errorf("turnFromstring: %w", err)
 	}
 	s, err := strconv.Atoi(parts[stepsPos])
 	if err != nil {
-		return "", 0, errors.New("invalid steps num")
+		return "", 0, fmt.Errorf("invalid steps num: %w", err)
 	}
 
 	return t, s, nil
 }
+
+type navigator struct {
+	record    chan position
+	pos       position
+	track     track
+	mu        *sync.Mutex
+	wg        *sync.WaitGroup
+	revisited []position
+}
+
+func (n *navigator) recordTrack(p position) {
+	n.mu.Lock()
+
+	defer func() {
+		n.mu.Unlock()
+	}()
+
+	if n.track.isVisited(p) {
+		n.revisited = append(n.revisited, p)
+	}
+
+	n.track.record(p)
+}
+
+func (n *navigator) start() {
+	n.wg.Add(1)
+
+	for p := range n.record {
+		n.recordTrack(p)
+	}
+
+	n.wg.Done()
+}
+
+func (n *navigator) stop() {
+	close(n.record)
+
+	n.wg.Wait()
+}
+
+func (n navigator) revisitedList() []position {
+	return n.revisited
+}
+
+func newNavigator() navigator {
+	return navigator{
+		record: make(chan position),
+		pos: position{
+			x: 0,
+			y: 0,
+		},
+		track:     newTrack(),
+		mu:        &sync.Mutex{},
+		wg:        &sync.WaitGroup{},
+		revisited: []position{},
+	}
+}
+
+type track map[position]bool
+
+func newTrack() track {
+	return make(track)
+}
+
+func (t track) record(p position) {
+	t[p] = true
+}
+
+func (t track) isVisited(p position) bool {
+	return t[p]
+}

internal/puzzles/solutions/2016/day01/solution_test.go

@@ -82,8 +82,6 @@ func Test_solution_Part1(t *testing.T) {
 }
 
 func Test_solution_Part2(t *testing.T) {
-	t.Skip()
-
 	type fields struct {
 		name string
 	}
@@ -99,7 +97,17 @@ func Test_solution_Part2(t *testing.T) {
 		want    string
 		wantErr bool
 	}{
-		{},
+		{
+			name: "",
+			fields: fields{
+				name: "",
+			},
+			args: args{
+				input: strings.NewReader("R8, R4, R4, R8"),
+			},
+			want:    "4",
+			wantErr: false,
+		},
 	}
 
 	for _, tt := range tests {

internal/puzzles/solutions/2016/day01/spec.md

@@ -1,5 +1,7 @@
 # --- Day 1: No Time for a Taxicab ---
 
+## Part One
+
 Santa's sleigh uses a very high-precision clock to guide its movements, and the clock's oscillator 
 is regulated by stars. Unfortunately, the stars have been stolen... by the Easter Bunny. 
 To save Christmas, Santa needs you to retrieve all fifty stars by December 25th.
@@ -13,7 +15,7 @@ You're airdropped near Easter Bunny Headquarters in a city somewhere.
 Document the Elves intercepted start here, and nobody had time to work them out further.
 
 The Document indicates that you should start at the given coordinates (where you just landed) and face North. 
-Then, follow the provided sequence: either turn left (L) or right (R) 90 degrees, 
+Then, follow the provided sequence: either turn left `(L)` or right `(R)` 90 degrees, 
 then walk forward the given number of blocks, ending at a new intersection.
 
 There's no time to follow such ridiculous instructions on foot, though, 
@@ -25,4 +27,13 @@ For example:
 - Following `R2, L3` leaves you `2` blocks East and `3` blocks North, or `5` blocks away.
 - `R2, R2, R2` leaves you `2` blocks due South of your starting position, which is `2` blocks away.
 - `R5, L5, R5, R3` leaves you `12` blocks away.
-How many blocks away is Easter Bunny HQ?
+How many blocks away is Easter Bunny HQ?
+
+## Part Two
+
+Then, you notice the instructions continue on the back of the Recruiting Document. Easter Bunny HQ is actually at the first 
+location you visit twice.
+
+For example, if your instructions are `R8, R4, R4, R8`, the first location you visit twice is `4` blocks away, due `East`.
+
+How many blocks away is the first location you visit twice?