2023 day06 optimised

Author: liamgallear

2023/day06/.bench

@@ -1 +1 @@
-{"Lines":[{"Name":"Part 1","N":4518816,"NsPerOp":263.3,"AllocedBytesPerOp":0,"AllocsPerOp":0,"MBPerS":0,"Measured":1,"Ord":0},{"Name":"Part 2","N":434,"NsPerOp":2776692,"AllocedBytesPerOp":0,"AllocsPerOp":0,"MBPerS":0,"Measured":1,"Ord":0}],"Measured":1}
+{"Lines":[{"Name":"Part 1","N":152954395,"NsPerOp":7.729,"AllocedBytesPerOp":0,"AllocsPerOp":0,"MBPerS":0,"Measured":1,"Ord":0},{"Name":"Part 2","N":622866195,"NsPerOp":1.906,"AllocedBytesPerOp":0,"AllocsPerOp":0,"MBPerS":0,"Measured":1,"Ord":0}],"Measured":1}

2023/day06/main.go

@@ -2,7 +2,9 @@ package main
 
 import (
 	_ "embed"
+	"math"
 	"os"
+	"strings"
 )
 
 //go:embed input.txt
@@ -11,36 +13,118 @@ var input string
 //go:embed input_test.txt
 var inputTest string
 
+type Race struct {
+	time, distance int
+}
+
+var races []Race
+var bigRace Race
+
 func main() {
 	// Check argv if we use test input or not
 	if len(os.Args) > 1 && os.Args[1] == "test" {
 		input = inputTest
 	}
 
-	answer := doPartOne(input)
+	parseInput(input)
+
+	answer := doPartOne()
 	println(answer)
 
-	answer = doPartTwo(input)
+	answer = doPartTwo()
 	println(answer)
 }
 
-type Race struct {
-	Time, Distance int
+func parseInput(input string) {
+	lines := strings.Split(strings.TrimSpace(input), "\n")
+
+	// Parse times and distances
+	times := parseNumbers(lines[0])
+	distances := parseNumbers(lines[1])
+
+	// Part 1: individual races
+	races = make([]Race, len(times))
+	for i := range races {
+		races[i] = Race{times[i], distances[i]}
+	}
+
+	// Part 2: concatenated race
+	bigRace = Race{concatenateNumbers(times), concatenateNumbers(distances)}
 }
 
-func getWays(r Race) int {
-	max := getVal(r, r.Time, -1)
-	min := getVal(r, 0, 1)
-	return max - min + 1
+func parseNumbers(line string) []int {
+	var nums []int
+	i := 0
+	for i < len(line) {
+		if line[i] >= '0' && line[i] <= '9' {
+			num := 0
+			for i < len(line) && line[i] >= '0' && line[i] <= '9' {
+				num = num*10 + int(line[i]-'0')
+				i++
+			}
+			nums = append(nums, num)
+		} else {
+			i++
+		}
+	}
+	return nums
 }
 
-func getVal(r Race, S, M int) int {
-	for i := 0; i < r.Time; i++ {
-		runtime := r.Time - (S + i*M)
-		D := (S + i*M) * runtime
-		if D > r.Distance {
-			return (S + i*M)
+func concatenateNumbers(nums []int) int {
+	result := 0
+	for _, n := range nums {
+		// Count digits in n
+		temp := n
+		multiplier := 1
+		for temp > 0 {
+			multiplier *= 10
+			temp /= 10
 		}
+		result = result*multiplier + n
+	}
+	return result
+}
+
+// Mathematical solution using quadratic formula
+// Distance d = h * (t - h) where h is hold time, t is total time
+// Need: h * (t - h) > record
+// Rearrange: -h² + t*h - record > 0
+// Solve: h² - t*h + record < 0
+// Using quadratic formula: h = (t ± sqrt(t² - 4*record)) / 2
+func getWays(r Race) int {
+	t := float64(r.time)
+	d := float64(r.distance)
+
+	// Discriminant
+	disc := t*t - 4*d
+	if disc < 0 {
+		return 0
+	}
+
+	sqrtDisc := math.Sqrt(disc)
+
+	// Two solutions from quadratic formula
+	h1 := (t - sqrtDisc) / 2
+	h2 := (t + sqrtDisc) / 2
+
+	// We need integer hold times strictly greater than the record
+	// Round up h1, round down h2
+	minHold := int(math.Floor(h1 + 1))
+	maxHold := int(math.Ceil(h2 - 1))
+
+	// Edge case: if h1 is exactly an integer, we need strictly greater
+	if h1 == math.Floor(h1) {
+		minHold = int(h1) + 1
+	}
+
+	// Edge case: if h2 is exactly an integer, we need strictly less
+	if h2 == math.Ceil(h2) {
+		maxHold = int(h2) - 1
 	}
-	return r.Time - S
+
+	if maxHold < minHold {
+		return 0
+	}
+
+	return maxHold - minHold + 1
 }

2023/day06/main_test.go

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

2023/day06/part1.go

@@ -1,24 +1,9 @@
 package main
 
-import (
-	"aocli/utils"
-	"strings"
-)
-
-func doPartOne(input string) int {
-	lines := strings.Split(strings.TrimSpace(input), "\n")
-	// Build up the races
-	T := strings.Fields(lines[0])[1:]
-	D := strings.Fields(lines[1])[1:]
-	R := make([]Race, len(T))
-	for i := range R {
-		R[i] = Race{utils.Atoi(T[i]), utils.Atoi(D[i])}
-	}
-
-	// Get the ways to win
-	ways := make([]int, len(R))
-	for i, r := range R {
-		ways[i] = getWays(r)
+func doPartOne() int {
+	result := 1
+	for _, r := range races {
+		result *= getWays(r)
 	}
-	return utils.MultiplyArray(ways)
+	return result
 }

2023/day06/part2.go

@@ -1,15 +1,5 @@
 package main
 
-import (
-	"aocli/utils"
-	"strings"
-)
-
-func doPartTwo(input string) int {
-	lines := strings.Split(strings.TrimSpace(input), "\n")
-	var R Race
-	R.Time = utils.Atoi(strings.Join(strings.Fields(lines[0])[1:], ""))
-	R.Distance = utils.Atoi(strings.Join(strings.Fields(lines[1])[1:], ""))
-
-	return getWays(R)
+func doPartTwo() int {
+	return getWays(bigRace)
 }