2025 day08

Author: liamgallear

2025/day08/.bench

@@ -0,0 +1 @@
+{"Lines":[{"Name":"Part 1","N":1620,"NsPerOp":693302,"AllocedBytesPerOp":0,"AllocsPerOp":0,"MBPerS":0,"Measured":1,"Ord":0},{"Name":"Part 2","N":1646,"NsPerOp":695120,"AllocedBytesPerOp":0,"AllocsPerOp":0,"MBPerS":0,"Measured":1,"Ord":0}],"Measured":1}

2025/day08/README.md

@@ -0,0 +1 @@
+<!-- You can add some comments here if you want to :D -->

2025/day08/main.go

@@ -0,0 +1,73 @@
+package main
+
+import (
+	_ "embed"
+	"fmt"
+	"os"
+	"strings"
+)
+
+//go:embed input.txt
+var input string
+
+//go:embed input_test.txt
+var inputTest string
+
+var (
+	junctions []coords
+	distances []distance
+)
+
+func main() {
+	// Check argv if we use test input or not
+	isTest := len(os.Args) > 1 && os.Args[1] == "test"
+	if isTest {
+		input = inputTest
+	}
+
+	// Parse input once
+	parseInput(input)
+
+	k := 1000
+	if isTest {
+		k = 10
+	}
+
+	answer := doPartOne(k)
+	println(answer)
+
+	answer = doPartTwo()
+	println(answer)
+}
+
+func parseInput(input string) {
+	lines := strings.Split(strings.TrimSpace(input), "\n")
+	junctions = make([]coords, len(lines))
+	for i, line := range lines {
+		fmt.Sscanf(line, "%d,%d,%d", &junctions[i].x, &junctions[i].y, &junctions[i].z)
+	}
+
+	// Calculate all pairwise distances
+	n := len(junctions)
+	distances = make([]distance, 0, n*(n-1)/2)
+	for i := 0; i < n; i++ {
+		j1 := junctions[i]
+		for j := i + 1; j < n; j++ {
+			j2 := junctions[j]
+			dx := j1.x - j2.x
+			dy := j1.y - j2.y
+			dz := j1.z - j2.z
+			if dx < 0 {
+				dx = -dx
+			}
+			if dy < 0 {
+				dy = -dy
+			}
+			if dz < 0 {
+				dz = -dz
+			}
+			d := dx*dx + dy*dy + dz*dz
+			distances = append(distances, distance{d: d, a: i, b: j})
+		}
+	}
+}

2025/day08/main_test.go

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

2025/day08/part1.go

@@ -0,0 +1,52 @@
+package main
+
+import (
+	"aocli/utils/union"
+	"slices"
+)
+
+type coords struct {
+	x, y, z int
+}
+
+type distance struct {
+	d    int
+	a, b int
+}
+
+func doPartOne(k int) int {
+	// Sort by distance (shortest first)
+	slices.SortFunc(distances, func(a, b distance) int {
+		return a.d - b.d
+	})
+
+	// Connect the k shortest pairs
+	uf := union.NewUnionFind(len(junctions))
+	for i := 0; i < k && i < len(distances); i++ {
+		uf.Union(distances[i].a, distances[i].b)
+	}
+
+	// Count component sizes
+	componentSizes := make(map[int]int)
+	for j := range junctions {
+		root := uf.Find(j)
+		componentSizes[root]++
+	}
+
+	// Get the sizes and sort them (largest first)
+	sizes := make([]int, 0, len(componentSizes))
+	for _, size := range componentSizes {
+		sizes = append(sizes, size)
+	}
+
+	// Sort descending
+	slices.SortFunc(sizes, func(a, b int) int {
+		return b - a
+	})
+
+	// Multiply the three largest
+	if len(sizes) < 3 {
+		return 0
+	}
+	return sizes[0] * sizes[1] * sizes[2]
+}

2025/day08/part2.go

@@ -0,0 +1,31 @@
+package main
+
+import (
+	"aocli/utils/union"
+	"slices"
+)
+
+func doPartTwo() int {
+	// Sort by distance (shortest first)
+	slices.SortFunc(distances, func(a, b distance) int {
+		return a.d - b.d
+	})
+
+	// Connect pairs until we have a spanning tree (n-1 connections)
+	uf := union.NewUnionFind(len(junctions))
+	ans := 0
+	connection := 0
+
+	for _, d := range distances {
+		if uf.Find(d.a) != uf.Find(d.b) {
+			connection++
+			if connection == len(junctions)-1 {
+				ans = junctions[d.a].x * junctions[d.b].x
+				break
+			}
+			uf.Union(d.a, d.b)
+		}
+	}
+
+	return ans
+}