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)
+}