Solution for 2023, day 21

Author: lucianoq

2023/21/Makefile

@@ -0,0 +1,17 @@
+main1:
+	go build -o main1 main1.go common.go
+
+main2:
+	go build -o main2 main2.go common.go
+
+.PHONY: run1 run2 clean
+
+run1: main1
+	./main1 <input
+
+run2: main2
+	./main2 <input
+
+clean:
+	rm -f main1 main2
+

2023/21/common.go

@@ -0,0 +1,67 @@
+package main
+
+import (
+	"bufio"
+	"os"
+	"strings"
+)
+
+type P struct{ x, y int }
+
+type Map struct {
+	m     []string
+	Start P
+	Size  int
+}
+
+var Delta = []P{{-1, 0}, {0, 1}, {1, 0}, {0, -1}}
+
+func (m Map) Get(p P) byte {
+	var mod = P{
+		x: ((p.x % m.Size) + m.Size) % m.Size,
+		y: ((p.y % m.Size) + m.Size) % m.Size,
+	}
+	return m.m[mod.x][mod.y]
+}
+
+func parse() Map {
+	scanner := bufio.NewScanner(os.Stdin)
+	var m Map
+	var start P
+	for r := 0; scanner.Scan(); r++ {
+		line := scanner.Text()
+		if idx := strings.IndexByte(line, 'S'); idx > -1 {
+			start.x = r
+			start.y = idx
+			line = line[:idx] + "." + line[idx+1:]
+		}
+		m.m = append(m.m, line)
+	}
+	m.Size = len(m.m)
+	m.Start = start
+	return m
+}
+
+func Reach(m Map, steps int) int {
+	reachable := map[int]map[P]struct{}{}
+	reachable[0] = map[P]struct{}{m.Start: {}}
+
+	for step := 1; step <= steps; step++ {
+		newSteps := map[P]struct{}{}
+
+		for p := range reachable[step-1] {
+			for _, delta := range Delta {
+				next := P{p.x + delta.x, p.y + delta.y}
+				if m.Get(next) == '#' {
+					continue
+				}
+				newSteps[next] = struct{}{}
+			}
+		}
+
+		reachable[step] = newSteps
+		delete(reachable, step-1)
+	}
+
+	return len(reachable[steps])
+}

2023/21/main1.go

@@ -0,0 +1,9 @@
+package main
+
+import "fmt"
+
+func main() {
+	m := parse()
+
+	fmt.Println(Reach(m, 64))
+}

2023/21/main2.go

@@ -0,0 +1,47 @@
+package main
+
+import (
+	"fmt"
+
+	"gonum.org/v1/gonum/mat"
+)
+
+const Steps = 26501365
+
+func main() {
+	m := parse()
+
+	// Find the 3 points necessary to generate the parabola coefficients
+
+	var points [3]P
+
+	for i, steps := range []int{
+		m.Size / 2,          // reach the border, fill one tile
+		m.Size/2 + m.Size,   // 5 tiles
+		m.Size/2 + 2*m.Size, // 13 tiles
+	} {
+		cells := Reach(m, steps)
+		points[i] = P{steps, cells}
+	}
+
+	// Given these 3 points, we can find a,b,c such as
+	// y = a*x^2 + b*x + c
+	a, b, c := FindParabola(points)
+
+	fmt.Println(int(a*Steps*Steps + b*Steps + c))
+}
+
+func FindParabola(p [3]P) (float64, float64, float64) {
+	A := mat.NewDense(3, 3, []float64{
+		float64(p[0].x * p[0].x), float64(p[0].x), 1,
+		float64(p[1].x * p[1].x), float64(p[1].x), 1,
+		float64(p[2].x * p[2].x), float64(p[2].x), 1,
+	})
+
+	y := mat.NewVecDense(3, []float64{float64(p[0].y), float64(p[1].y), float64(p[2].y)})
+
+	var b mat.VecDense
+	_ = b.SolveVec(A, y)
+
+	return b.AtVec(0), b.AtVec(1), b.AtVec(2)
+}