2025 day11

Author: liamgallear

2025/day11/.bench

@@ -0,0 +1 @@
+{"Lines":[{"Name":"Part 1","N":8934,"NsPerOp":126031,"AllocedBytesPerOp":0,"AllocsPerOp":0,"MBPerS":0,"Measured":1,"Ord":0},{"Name":"Part 2","N":3385,"NsPerOp":345191,"AllocedBytesPerOp":0,"AllocsPerOp":0,"MBPerS":0,"Measured":1,"Ord":0}],"Measured":1}

2025/day11/README.md

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

2025/day11/main.go

@@ -0,0 +1,33 @@
+package main
+
+import (
+	_ "embed"
+	"os"
+)
+
+//go:embed input.txt
+var input string
+
+//go:embed input_test.txt
+var inputTest string
+
+//go:embed input_test2.txt
+var inputTest2 string
+
+func main() {
+	// Check argv if we use test input or not
+	if len(os.Args) > 1 && os.Args[1] == "test" {
+		answer := doPartOne(inputTest)
+		println(answer)
+
+		answer = doPartTwo(inputTest2)
+		println(answer)
+		return
+	}
+
+	answer := doPartOne(input)
+	println(answer)
+
+	answer = doPartTwo(input)
+	println(answer)
+}

2025/day11/main_test.go

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

2025/day11/part1.go

@@ -0,0 +1,47 @@
+package main
+
+import "strings"
+
+func doPartOne(input string) int {
+	lines := strings.Split(strings.TrimSpace(input), "\n")
+
+	// Build the adjacency list graph
+	devices := make(map[string][]string)
+	for _, line := range lines {
+		s := strings.Fields(line)
+		device := strings.TrimSuffix(s[0], ":")
+		devices[device] = s[1:]
+	}
+
+	// Count all paths from "you" to "out"
+	pathCount := countPaths(devices, "you", "out", make(map[string]bool))
+
+	return pathCount
+}
+
+// countPaths uses DFS to count all paths from start to end
+func countPaths(graph map[string][]string, current, target string, visited map[string]bool) int {
+	// If we reached the target, we found a path
+	if current == target {
+		return 1
+	}
+
+	// Mark current node as visited
+	visited[current] = true
+	defer func() { visited[current] = false }() // Unmark when backtracking
+
+	totalPaths := 0
+
+	// Explore all neighbors
+	for _, neighbor := range graph[current] {
+		// Skip if already visited (avoid cycles)
+		if visited[neighbor] {
+			continue
+		}
+
+		// Recursively count paths from neighbor to target
+		totalPaths += countPaths(graph, neighbor, target, visited)
+	}
+
+	return totalPaths
+}

2025/day11/part2.go

@@ -0,0 +1,80 @@
+package main
+
+import "strings"
+
+func doPartTwo(input string) int {
+	lines := strings.Split(strings.TrimSpace(input), "\n")
+
+	// Build the adjacency list graph
+	devices := make(map[string][]string)
+	for _, line := range lines {
+		s := strings.Fields(line)
+		device := strings.TrimSuffix(s[0], ":")
+		devices[device] = s[1:]
+	}
+
+	// Count paths from "svr" to "out" that visit both "dac" and "fft"
+	memo := make(map[string]int)
+	pathCount := countPathsWithRequiredMemo(devices, "svr", "out", []string{"dac", "fft"}, make(map[string]bool), make(map[string]bool), memo)
+
+	return pathCount
+}
+
+// countPathsWithRequiredMemo counts paths with memoization
+func countPathsWithRequiredMemo(graph map[string][]string, current, target string, required []string, visited map[string]bool, foundRequired map[string]bool, memo map[string]int) int {
+	// If we reached the target
+	if current == target {
+		// Check if all required nodes were visited
+		for _, req := range required {
+			if !foundRequired[req] {
+				return 0
+			}
+		}
+		return 1
+	}
+
+	// Create memo key from current node and which required nodes have been found
+	memoKey := current
+	for _, req := range required {
+		if foundRequired[req] {
+			memoKey += "+" + req
+		}
+	}
+
+	// Check memo
+	if val, exists := memo[memoKey]; exists {
+		return val
+	}
+
+	// Mark current node as visited
+	visited[current] = true
+	defer func() { visited[current] = false }()
+
+	// Check if current node is a required node
+	wasFound := make(map[string]bool)
+	for _, req := range required {
+		if current == req && !foundRequired[req] {
+			foundRequired[req] = true
+			wasFound[req] = true
+		}
+	}
+	defer func() {
+		for req := range wasFound {
+			foundRequired[req] = false
+		}
+	}()
+
+	totalPaths := 0
+
+	// Explore all neighbors
+	for _, neighbor := range graph[current] {
+		if visited[neighbor] {
+			continue
+		}
+
+		totalPaths += countPathsWithRequiredMemo(graph, neighbor, target, required, visited, foundRequired, memo)
+	}
+
+	memo[memoKey] = totalPaths
+	return totalPaths
+}