refactor(2025): massive performance increase in day 9 part 2

Author: believer

go/2025/puzzles/day09/main.go

@@ -15,6 +15,9 @@ import (
 // Then I found the line in the problem that says adjacent coordinates are
 // on the same column or row, which made boundary calculations easier.
 
+// Edit: Found a faster solution using slice bounds instead of a map
+// TODO:<Perf> Add performance from M1 Mac for old solution and new
+
 func main() {
 	fmt.Println("Part 1: ", part1("input.txt"))
 	fmt.Println("Part 2: ", part2("input.txt"))
@@ -53,7 +56,7 @@ type Rectangle struct {
 func part2(name string) (largestArea int) {
 	lines := files.ReadLines(name)
 	coords := createCoordinates(lines)
-	boundaries := createBoundaries(coords)
+	bounds, minY := createBoundariesSlice(coords)
 
 	// Create all rectangles first. Might be bad for
 	// performance, but I like how it looks
@@ -81,7 +84,7 @@ func part2(name string) (largestArea int) {
 
 	// Find the first valid
 	for _, r := range rectangles {
-		if isRectangleValid(r, boundaries) {
+		if isRectangleValid(r, bounds, minY) {
 			largestArea = r.Area
 			break
 		}
@@ -104,20 +107,22 @@ func createCoordinates(lines []string) (coords []grid.Point) {
 }
 
 // This is slow because of, potentially, a lot of checks
-func isRectangleValid(r Rectangle, boundaries map[int][2]int) bool {
+func isRectangleValid(r Rectangle, boundaries []Bounds, minY int) bool {
 	minX := min(r.P1.X, r.P2.X)
 	maxX := max(r.P1.X, r.P2.X)
-	minY := min(r.P1.Y, r.P2.Y)
-	maxY := max(r.P1.Y, r.P2.Y)
+	loY := min(r.P1.Y, r.P2.Y)
+	hiY := max(r.P1.Y, r.P2.Y)
 
-	for y := minY; y <= maxY; y++ {
-		bounds, ok := boundaries[y]
+	for y := loY; y <= hiY; y++ {
+		index := y - minY
 
-		if !ok {
+		if index < 0 || index >= len(boundaries) {
 			return false
 		}
 
-		if minX < bounds[0] || maxX > bounds[1] {
+		b := boundaries[index]
+
+		if !b.Ok || minX < b.Min || maxX > b.Max {
 			return false
 		}
 	}
@@ -130,53 +135,72 @@ func isRectangleValid(r Rectangle, boundaries map[int][2]int) bool {
 // your list will always be on either the same row or the same column".
 // So, we can find vertical and horizontal edges
 
-// row ->  [min_x, max_x]
-func createBoundaries(coords []grid.Point) map[int][2]int {
-	boundaries := map[int][2]int{}
+type Bounds struct {
+	Min, Max int
+	Ok       bool
+}
+
+// First solution had a map of minX, maxX. But, this was slow when checking
+// for valid rectangles. This returns a slice and minY for faster lookup with y-minY.
+func createBoundariesSlice(coords []grid.Point) ([]Bounds, int) {
+	if len(coords) == 0 {
+		return nil, 0
+	}
+
+	// Find global Y-range
+	minY := coords[0].Y
+	maxY := coords[0].Y
+
+	for _, c := range coords {
+		minY = min(c.Y, minY)
+		maxY = max(c.Y, maxY)
+	}
 
-	for i, c := range coords {
-		p1 := c
-		p2 := coords[(i+1)%len(coords)] // List wraps around
+	// Allocate bounds
+	size := maxY - minY + 1
+	bounds := make([]Bounds, size)
+
+	// Build similar to your map version
+	for i := range coords {
+		p1 := coords[i]
+		p2 := coords[(i+1)%len(coords)]
 
 		x1, y1 := p1.X, p1.Y
 		x2, y2 := p2.X, p2.Y
 
 		if x1 == x2 {
 			// Same x, create vertical edge from min y to max y
-			minY := min(y1, y2)
-			maxY := max(y1, y2) + 1
-
-			for y := minY; y < maxY; y++ {
-				if _, ok := boundaries[y]; !ok {
-					boundaries[y] = [2]int{x1, x1}
-				} else {
-					cx1 := boundaries[y][0]
-					cx2 := boundaries[y][1]
+			lo := min(y1, y2)
+			hi := max(y1, y2)
 
-					minX := min(cx1, x1)
-					maxX := max(cx2, x1)
+			for y := lo; y <= hi; y++ {
+				idx := y - minY
 
-					boundaries[y] = [2]int{minX, maxX}
+				if !bounds[idx].Ok {
+					bounds[idx] = Bounds{Min: x1, Max: x1, Ok: true}
+				} else {
+					b := bounds[idx]
+					b.Min = min(x1, b.Min)
+					b.Max = max(x1, b.Max)
+					bounds[idx] = b
 				}
 			}
 		} else if y1 == y2 {
 			// same y, create horizontal edge from mix to max x
+			row := y1 - minY
 
-			if _, ok := boundaries[y1]; !ok {
-				boundaries[y1] = [2]int{min(x1, x2), max(x1, x2)}
+			if !bounds[row].Ok {
+				bounds[row] = Bounds{Min: min(x1, x2), Max: max(x1, x2), Ok: true}
 			} else {
-				cx1 := boundaries[y1][0]
-				cx2 := boundaries[y1][1]
-
-				minX := min(min(cx1, x1), x2)
-				maxX := max(max(cx2, x1), x2)
-
-				boundaries[y1] = [2]int{minX, maxX}
+				b := bounds[row]
+				b.Min = min(min(x1, x2), b.Min)
+				b.Max = max(max(x1, x2), b.Max)
+				bounds[row] = b
 			}
 		}
 	}
 
-	return boundaries
+	return bounds, minY
 }
 
 // math.Min / math.Max use float64s so these helpers