Add solution day 15 part 1

Author: terminalnode

README.md

@@ -46,7 +46,7 @@ automatically rebuilt and redeployed ever time the `common` module or their own
 | Day | Solution | Day | Solution |
 |-----|----------|-----|----------|
 | 01  | ⭐ ⭐      | 14  | ⭐ ⭐      |
-| 02  | ⭐ ⭐      | 15  |          |
+| 02  | ⭐ ⭐      | 15  | ⭐        |
 | 03  | ⭐ ⭐      | 16  |          |
 | 04  | ⭐ ⭐      | 17  |          |
 | 05  | ⭐ ⭐      | 18  |          |

common/util/coordinate.go

@@ -31,6 +31,10 @@ func (c Coordinate) Modulo(x int, y int) Coordinate {
 	return Coordinate{X: c.X % x, Y: c.Y % y}
 }
 
+func (c Coordinate) Equals(c2 Coordinate) bool {
+	return c.X == c2.X && c.Y == c2.Y
+}
+
 func (c Coordinate) PositiveModulo(x int, y int) Coordinate {
 	// This is similar to how modulo works in Python
 	// See: https://stackoverflow.com/questions/13794171/how-to-make-the-mod-of-a-negative-number-to-be-positive/13794192

solutions/day15/main.go

@@ -1,9 +1,71 @@
 package main
 
 import (
+	"fmt"
 	"github.com/terminalnode/adventofcode2024/common"
+	"github.com/terminalnode/adventofcode2024/common/util"
 )
 
 func main() {
-	common.Setup(15, nil, nil)
+	common.Setup(15, part1, nil)
+}
+
+func part1(
+	input string,
+) string {
+	p, err := parse(input)
+	if err != nil {
+		return fmt.Sprintf("Failed to parse input: %v", err)
+	}
+
+	for _, move := range p.moves {
+		endPosition, err := findEndPosition(p.warehouse, p.robot, move)
+		if err != nil {
+			continue
+		}
+
+		newRobot := move(p.robot)
+		if !newRobot.Equals(endPosition) {
+			// End position is more than one step, meaning we need to move boxes
+			p.warehouse[newRobot.Y][newRobot.X] = GROUND
+			p.warehouse[endPosition.Y][endPosition.X] = BOX
+		}
+		p.robot = newRobot
+	}
+
+	return fmt.Sprintf("Sum of all GPS coordinates: %d", score(p.warehouse))
+}
+
+func findEndPosition(
+	w warehouseMatrix,
+	s util.Coordinate,
+	d util.Direction,
+) (util.Coordinate, error) {
+	np := d(s)
+	ch := w[np.Y][np.X]
+	switch ch {
+	case GROUND:
+		return np, nil
+	case BOX:
+		return findEndPosition(w, np, d)
+	case WALL:
+		return np, fmt.Errorf("wall hit")
+	}
+
+	panic(fmt.Sprintf("Invalid character: %c", ch))
+}
+
+func score(
+	wh warehouseMatrix,
+) int {
+	sum := 0
+	for y, row := range wh {
+		for x, ch := range row {
+			if ch != BOX {
+				continue
+			}
+			sum += x + 100*y
+		}
+	}
+	return sum
 }

solutions/day15/parse.go

@@ -0,0 +1,122 @@
+package main
+
+import (
+	"fmt"
+	"github.com/terminalnode/adventofcode2024/common/util"
+	"strings"
+)
+
+type warehouseMatrix = [][]int32
+type moveList = []util.Direction
+type robotPosition = util.Coordinate
+
+type problem struct {
+	robot     robotPosition
+	warehouse warehouseMatrix
+	moves     moveList
+}
+
+const (
+	WALL   = '#'
+	BOX    = 'O'
+	ROBOT  = '@'
+	GROUND = '.'
+)
+
+func parse(
+	input string,
+) (problem, error) {
+	whRaw, mRaw, err := splitInput(input)
+	if err != nil {
+		return problem{}, err
+	}
+
+	wh, r, err := parseWarehouse(whRaw)
+
+	m, err := parseMoves(mRaw)
+	if err != nil {
+		return problem{}, err
+	}
+
+	return problem{
+		robot:     r,
+		warehouse: wh,
+		moves:     m,
+	}, nil
+}
+
+func splitInput(
+	input string,
+) (string, string, error) {
+	split := strings.Split(input, "\n\n")
+	if len(split) != 2 {
+		return "", "", fmt.Errorf("expected input to have two parts, but was %d", len(split))
+	}
+	return split[0], split[1], nil
+}
+
+func parseWarehouse(
+	wh string,
+) (warehouseMatrix, util.Coordinate, error) {
+	lines := strings.Split(wh, "\n")
+	out := make(warehouseMatrix, len(lines))
+	robot := util.Coordinate{}
+	foundRobot := false
+
+	for y, line := range lines {
+		out[y] = []int32(line)
+		for x, ch := range line {
+			if ch != WALL && ch != ROBOT && ch != BOX && ch != GROUND {
+				return out, robot, fmt.Errorf("invalid character in warehouse matrix: %c", ch)
+			}
+
+			if ch != ROBOT {
+				continue
+			}
+			foundRobot = true
+			robot = util.Coordinate{X: x, Y: y}
+			out[y][x] = GROUND
+		}
+	}
+
+	if !foundRobot {
+		return out, robot, fmt.Errorf("no robot in input")
+	}
+
+	return out, robot, nil
+}
+
+func parseMoves(
+	m string,
+) (moveList, error) {
+	ms := make(moveList, 0, len(m))
+	for _, ch := range m {
+		if ch == '\n' {
+			// As per instructions, ignore new lines
+			continue
+		}
+
+		newMove, err := charToDirection(ch)
+		if err != nil {
+			return ms, err
+		}
+		ms = append(ms, newMove)
+	}
+	return ms, nil
+}
+
+func charToDirection(
+	ch int32,
+) (util.Direction, error) {
+	switch ch {
+	case '^':
+		return util.Coordinate.North, nil
+	case 'v':
+		return util.Coordinate.South, nil
+	case '>':
+		return util.Coordinate.East, nil
+	case '<':
+		return util.Coordinate.West, nil
+	}
+	return nil, fmt.Errorf("invalid direction '%c'", ch)
+}