feat(2024): add day 14

believer · believer · commit a3f28eb2691d · 2024-12-14T07:57:25.000+01:00
diff --git a/go/2024/README.md b/go/2024/README.md
@@ -27,6 +27,7 @@ Collect stars by solving puzzles. Two puzzles will be made available on each day
 | [Day 11: Plutonian Pebbles](https://github.com/believer/advent-of-code/blob/master/go/2024/puzzles/day11/main.go)    | 🌟  |        187738 | 🌟  | 223767210249237 |
 | [Day 12: Garden Groups](https://github.com/believer/advent-of-code/blob/master/go/2024/puzzles/day12/main.go)        | 🌟  |       1522850 | 🌟  |          953738 |
 | [Day 13: Claw Contraption](https://github.com/believer/advent-of-code/blob/master/go/2024/puzzles/day13/main.go)     | 🌟  |         26299 | 🌟  | 107824497933339 |
+| [Day 14: Restroom Redoubt](https://github.com/believer/advent-of-code/blob/master/go/2024/puzzles/day14/main.go)     | 🌟  |     228690000 | 🌟  |            7093 |
 
 ## Benchmarks
 
@@ -47,6 +48,7 @@ Using Go's built-in benchmarking with the [testing](https://pkg.go.dev/testing#h
 | 11  |    424021 ns/op |   15488584 ns/op |                     |
 | 12  |   6677348 ns/op |   12339733 ns/op | `39.21%` / `26.80%` |
 | 13  |    698173 ns/op |     702380 ns/op | `75.93%` / -        |
+| 14  |    594981 ns/op |   56488050 ns/op |                     |
 
 \* compared to first solution
 
diff --git a/go/2024/puzzles/day14/main.go b/go/2024/puzzles/day14/main.go
@@ -0,0 +1,132 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/believer/aoc-2024/utils"
+	"github.com/believer/aoc-2024/utils/files"
+	"github.com/believer/aoc-2024/utils/grid"
+)
+
+func main() {
+	fmt.Println("Part 1: ", part1("input.txt", 101, 103))
+	fmt.Println("Part 2: ", part2("input.txt", 101, 103))
+}
+
+type Robot struct {
+	position grid.Point
+	velocity grid.Point
+}
+
+func part1(name string, width, height int) int {
+	lines := files.ReadLines(name)
+	tiles := grid.FromSize(width, height)
+	robots := parseRobots(lines)
+	safetyFactor := 1
+
+	// Move robots
+	for range 100 {
+		for i, robot := range robots {
+			next := robot.position.Add(robot.velocity)
+
+			// Increment or set number of guard in next location
+			if v := tiles.GetWithWrap(next); v >= '0' && v <= '9' {
+				tiles.UpdateWithWrap(next, v+1)
+			} else {
+				tiles.UpdateWithWrap(next, '1')
+			}
+
+			// Decrement or set old position to empty
+			if v := tiles.GetWithWrap(robot.position); v > '1' && v <= '9' {
+				tiles.UpdateWithWrap(robot.position, v-1)
+			} else {
+				tiles.UpdateWithWrap(robot.position, '.')
+			}
+
+			robots[i].position = next
+		}
+	}
+
+	// Get data from quadrants
+	for _, q := range tiles.GetQuadrants() {
+		robots := 0
+
+		for _, b := range q {
+			if b == '.' {
+				continue
+			}
+
+			robots += int(b - '0')
+		}
+
+		safetyFactor *= robots
+	}
+
+	return safetyFactor
+}
+
+func part2(name string, width, height int) int {
+	lines := files.ReadLines(name)
+	tiles := grid.FromSize(width, height)
+	robots := parseRobots(lines)
+	seconds := 0
+
+	// Move robots
+	for s := range 10000 {
+		for i, robot := range robots {
+			next := robot.position.Add(robot.velocity)
+
+			// Increment or set number of guard in next location
+			if v := tiles.GetWithWrap(next); v >= '0' && v <= '9' {
+				tiles.UpdateWithWrap(next, v+1)
+			} else {
+				tiles.UpdateWithWrap(next, '1')
+			}
+
+			// Decrement or set old position to empty
+			if v := tiles.GetWithWrap(robot.position); v > '1' && v <= '9' {
+				tiles.UpdateWithWrap(robot.position, v-1)
+			} else {
+				tiles.UpdateWithWrap(robot.position, '.')
+			}
+
+			robots[i].position = next
+		}
+
+		// Assume that for a Christmas tree to appear there are no overlapping guards
+		overlaps := true
+
+		for _, d := range tiles.Data {
+			if d != '1' && d != '.' {
+				overlaps = false
+			}
+		}
+
+		if overlaps {
+			// Zero based indexing
+			seconds = s + 1
+			break
+		}
+	}
+
+	return seconds
+}
+
+func parseRobots(lines []string) []Robot {
+	robots := []Robot{}
+
+	// Parse out robots
+	for _, line := range lines {
+		position, velocity, _ := strings.Cut(line, " ")
+		x, y, _ := strings.Cut(position[2:], ",")
+		vx, vy, _ := strings.Cut(velocity[2:], ",")
+
+		robots = append(robots, Robot{
+			position: grid.Point{X: utils.MustIntFromString(x), Y: utils.MustIntFromString(y)},
+			velocity: grid.Point{X: utils.MustIntFromString(vx), Y: utils.MustIntFromString(vy)},
+		})
+	}
+
+	return robots
+}
diff --git a/go/2024/puzzles/day14/main_test.go b/go/2024/puzzles/day14/main_test.go
@@ -0,0 +1,30 @@
+package main
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestPart1(t *testing.T) {
+	t.Run("Part 1", func(t *testing.T) {
+		expected := 12
+		actual := part1("test-input.txt", 11, 7)
+		assert.Equal(t, expected, actual)
+	})
+}
+
+// No test for part 2 since there is no way of getting
+// a Christmas tree for so few guards.
+
+func BenchmarkPart1(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		part1("input.txt", 11, 7)
+	}
+}
+
+func BenchmarkPart2(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		part2("input.txt", 11, 7)
+	}
+}
diff --git a/go/2024/puzzles/day14/test-input.txt b/go/2024/puzzles/day14/test-input.txt
@@ -0,0 +1,12 @@
+p=0,4 v=3,-3
+p=6,3 v=-1,-3
+p=10,3 v=-1,2
+p=2,0 v=2,-1
+p=0,0 v=1,3
+p=3,0 v=-2,-2
+p=7,6 v=-1,-3
+p=3,0 v=-1,-2
+p=9,3 v=2,3
+p=7,3 v=-1,2
+p=2,4 v=2,-3
+p=9,5 v=-3,-3
diff --git a/go/2024/utils/grid/grid.go b/go/2024/utils/grid/grid.go
@@ -62,10 +62,33 @@ func New(lines []string) Grid {
 	}
 }
 
+func FromSize(width, height int) Grid {
+	data := make([]byte, width*height)
+
+	for i := range data {
+		data[i] = '.'
+	}
+
+	return Grid{
+		Data:   data,
+		Height: height,
+		Width:  width,
+	}
+}
+
 func (g *Grid) Get(p Point) byte {
 	return g.Data[g.Width*p.Y+p.X]
 }
 
+func (g *Grid) GetWithWrap(p Point) byte {
+	// Wrap coordinates to ensure they stay within bounds
+	wrappedX := (p.X%g.Width + g.Width) % g.Width
+	wrappedY := (p.Y%g.Height + g.Height) % g.Height
+
+	// Update the grid at the wrapped position
+	return g.Data[g.Width*wrappedY+wrappedX]
+}
+
 func (g *Grid) Contains(p Point) (byte, bool) {
 	if p.X >= 0 && p.X < g.Width && p.Y >= 0 && p.Y < g.Height {
 		return g.Get(p), true
@@ -78,6 +101,15 @@ func (g *Grid) Update(p Point, b byte) {
 	g.Data[g.Width*p.Y+p.X] = b
 }
 
+func (g *Grid) UpdateWithWrap(p Point, b byte) {
+	// Wrap coordinates to ensure they stay within bounds
+	wrappedX := (p.X%g.Width + g.Width) % g.Width
+	wrappedY := (p.Y%g.Height + g.Height) % g.Height
+
+	// Update the grid at the wrapped position
+	g.Data[g.Width*wrappedY+wrappedX] = b
+}
+
 // Find exactly _one_ point for the given value
 func (g *Grid) Find(needle byte) Point {
 	for i, v := range g.Data {
@@ -108,11 +140,49 @@ func (g *Grid) FindAll(needle byte) []Point {
 	return points
 }
 
+func (g *Grid) GetQuadrant(q int) []byte {
+	var startX, startY, endX, endY int
+
+	halfWidth := g.Width / 2
+	halfHeight := g.Height / 2
+
+	switch q {
+	case 1: // Top-Left
+		startX, startY, endX, endY = 0, 0, halfWidth, halfHeight
+	case 2: // Top-Right
+		startX, startY, endX, endY = halfWidth+1, 0, g.Width, halfHeight
+	case 3: // Bottom-Left
+		startX, startY, endX, endY = 0, halfHeight+1, halfWidth, g.Height
+	case 4: // Bottom-Right
+		startX, startY, endX, endY = halfWidth+1, halfHeight+1, g.Width, g.Height
+	default:
+		panic("Invalid quadrant number")
+	}
+
+	quadrantData := make([]byte, 0, (endX-startX)*(endY-startY))
+	for y := startY; y < endY; y++ {
+		quadrantData = append(quadrantData, g.Data[y*g.Width+startX:y*g.Width+endX]...)
+	}
+
+	return quadrantData
+}
+
+func (g *Grid) GetQuadrants() [][]byte {
+	return [][]byte{
+		g.GetQuadrant(1),
+		g.GetQuadrant(2),
+		g.GetQuadrant(3),
+		g.GetQuadrant(4),
+	}
+}
+
 func (g *Grid) Debug() {
 	for y := range g.Height {
 		for x := range g.Width {
 			fmt.Print(string(g.Get(Point{X: x, Y: y})))
 		}
 		fmt.Println()
 	}
+
+	fmt.Println()
 }
