2023 day08 optimised

Author: liamgallear

2023/day08/.bench

@@ -1 +1 @@
-{"Lines":[{"Name":"Part 1","N":1327,"NsPerOp":911496,"AllocedBytesPerOp":0,"AllocsPerOp":0,"MBPerS":0,"Measured":1,"Ord":0},{"Name":"Part 2","N":220,"NsPerOp":5524126,"AllocedBytesPerOp":0,"AllocsPerOp":0,"MBPerS":0,"Measured":1,"Ord":0}],"Measured":1}
+{"Lines":[{"Name":"Part 1","N":4512,"NsPerOp":263697,"AllocedBytesPerOp":0,"AllocsPerOp":0,"MBPerS":0,"Measured":1,"Ord":0},{"Name":"Part 2","N":738,"NsPerOp":1584917,"AllocedBytesPerOp":0,"AllocsPerOp":0,"MBPerS":0,"Measured":1,"Ord":0}],"Measured":1}

2023/day08/main.go

@@ -1,10 +1,8 @@
 package main
 
 import (
-	"aocli/utils"
 	_ "embed"
 	"os"
-	"strings"
 )
 
 //go:embed input.txt
@@ -26,51 +24,76 @@ func main() {
 	println(answer)
 }
 
-type Maps map[rune]map[string]string
+type Node struct {
+	left  string
+	right string
+}
 
-func solve(input string, suffix string) int {
-	lines := strings.Split(strings.TrimSpace(input), "\n\n")
-	instr := []rune(lines[0])
-	maps := buildMaps(lines[1])
-	P := []string{}
-	for p := range maps['L'] {
-		if strings.HasSuffix(p, suffix) {
-			P = append(P, p)
-		}
-	}
+var (
+	instructions string
+	network      map[string]Node
+	startNodes   []string
+)
 
-	I := []int{}
+func parseInput(input string) {
 	i := 0
-	for {
-		NP := []string{}
-		for _, p := range P {
-			p = maps[instr[i%len(instr)]][p]
-			if strings.HasSuffix(p, "Z") {
-				I = append(I, i+1)
-				if len(I) == len(P) {
-					return utils.LCM(1, I[0], I[1:]...)
-				}
-			}
-			NP = append(NP, p)
-		}
-		P = NP
+	// Skip whitespace
+	for i < len(input) && (input[i] == ' ' || input[i] == '\n' || input[i] == '\r') {
+		i++
+	}
+
+	// Parse instructions
+	start := i
+	for i < len(input) && input[i] != '\n' {
+		i++
+	}
+	instructions = input[start:i]
+
+	// Skip blank lines
+	for i < len(input) && (input[i] == '\n' || input[i] == '\r') {
 		i++
 	}
+
+	// Parse network
+	network = make(map[string]Node)
+	startNodes = make([]string, 0, 6)
+
+	for i < len(input) {
+		if input[i] == '\n' || input[i] == '\r' {
+			i++
+			continue
+		}
+
+		// Parse: "AAA = (BBB, CCC)"
+		name := input[i : i+3]
+		i += 7 // Skip " = ("
+		left := input[i : i+3]
+		i += 5 // Skip ", "
+		right := input[i : i+3]
+		i += 4 // Skip ")\n"
+
+		network[name] = Node{left: left, right: right}
+		if name[2] == 'A' {
+			startNodes = append(startNodes, name)
+		}
+	}
+}
+
+func gcd(a, b int) int {
+	for b != 0 {
+		a, b = b, a%b
+	}
+	return a
+}
+
+func lcm(a, b int) int {
+	return a * b / gcd(a, b)
 }
 
-func buildMaps(line string) Maps {
-	lines := strings.Split(line, "\n")
-	maps := make(map[rune]map[string]string, 2)
-	maps['L'] = make(map[string]string, len(lines))
-	maps['R'] = make(map[string]string, len(lines))
-	for _, line := range lines {
-		s := strings.Split(line, " = ")
-		I := s[0]
-		lr := strings.Split(s[1], ", ")
-		L := lr[0][1:]
-		R := lr[1][:3]
-		maps['L'][I] = L
-		maps['R'][I] = R
+func lcmSlice(nums []int) int {
+	result := nums[0]
+	for i := 1; i < len(nums); i++ {
+		result = lcm(result, nums[i])
 	}
-	return maps
+	return result
 }

2023/day08/main_test.go

@@ -3,12 +3,16 @@ package main
 import "testing"
 
 func BenchmarkPartOne(b *testing.B) {
+	parseInput(input)
+	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
 		doPartOne(input)
 	}
 }
 
 func BenchmarkPartTwo(b *testing.B) {
+	parseInput(input)
+	b.ResetTimer()
 	for n := 0; n < b.N; n++ {
 		doPartTwo(input)
 	}

2023/day08/part1.go

@@ -1,5 +1,19 @@
 package main
 
 func doPartOne(input string) int {
-	return solve(input, "AAA")
+	current := "AAA"
+	steps := 0
+	instrLen := len(instructions)
+
+	for current != "ZZZ" {
+		node := network[current]
+		if instructions[steps%instrLen] == 'L' {
+			current = node.left
+		} else {
+			current = node.right
+		}
+		steps++
+	}
+
+	return steps
 }

2023/day08/part2.go

@@ -1,5 +1,26 @@
 package main
 
 func doPartTwo(input string) int {
-	return solve(input, "A")
+	// Find cycle length for each starting node
+	cycles := make([]int, 0, len(startNodes))
+	instrLen := len(instructions)
+
+	for _, start := range startNodes {
+		current := start
+		steps := 0
+
+		for current[2] != 'Z' {
+			node := network[current]
+			if instructions[steps%instrLen] == 'L' {
+				current = node.left
+			} else {
+				current = node.right
+			}
+			steps++
+		}
+
+		cycles = append(cycles, steps)
+	}
+
+	return lcmSlice(cycles)
 }