Add solution day 13 part 2

Author: terminalnode

README.md

@@ -57,4 +57,4 @@ automatically rebuilt and redeployed ever time the `common` module or their own
 | 10  | ⭐ ⭐      | 23  |          |
 | 11  | ⭐ ⭐      | 24  |          |
 | 12  | ⭐ ⭐      | 25  |          |
-| 13  | ⭐        |     |          |
+| 13  | ⭐ ⭐      |     |          |

solutions/day13/main.go

@@ -3,74 +3,34 @@ package main
 import (
 	"fmt"
 	"github.com/terminalnode/adventofcode2024/common"
-	"log"
-	"math"
 )
 
-func main() {
-	common.Setup(13, part1, nil)
-}
+func main()                     { common.Setup(13, part1, part2) }
+func part1(input string) string { return solve(input, false) }
+func part2(input string) string { return solve(input, true) }
 
-func part1(
+func solve(
 	input string,
+	part2 bool,
 ) string {
-	problems, err := parseProblems(input)
+	problems, err := parseProblems(input, part2)
 	if err != nil {
 		return fmt.Sprintf("Failed to parse input: %v", err)
 	}
 
 	sum := int64(0)
 	for _, p := range problems {
-		minTokenCost := findMinTokenCost(p)
-		if minTokenCost != -1 {
-			sum += minTokenCost
-		}
-	}
-
-	return fmt.Sprintf("At least %d tokens to solve these %d claw machines", sum, len(problems))
-}
-
-func findMinTokenCost(
-	p problem,
-) int64 {
-	smallest := int64(math.MaxInt64)
-
-	for timesA := int64(0); true; timesA++ {
-		cX := timesA * p.aX
-		cY := timesA * p.aY
-		if cX > p.goalX || cY > p.goalY {
-			break
-		}
-
-		minMoves := findMinTokenCostAfterA(cX, cY, timesA, p)
-		if minMoves != -1 && minMoves < smallest {
-			log.Printf("New smallest! %d", minMoves)
-			smallest = minMoves
-		}
-	}
-
-	if smallest == math.MaxInt64 {
-		return -1
-	}
-	return smallest
-}
-
-func findMinTokenCostAfterA(
-	cX int64,
-	cY int64,
-	timesA int64,
-	p problem,
-) int64 {
-	for timesB := int64(0); true; timesB++ {
-		newX := timesB*p.bX + cX
-		newY := timesB*p.bY + cY
-
-		if newX > p.goalX || newY > p.goalY {
-			break
-		} else if newX == p.goalX && newY == p.goalY {
-			return timesA*3 + timesB
+		// Apparently this is an application of some Cramer's rule. ¯\_(ツ)_/¯
+		det := p.aX*p.bY - p.aY*p.bX
+		a := (p.goalX*p.bY - p.goalY*p.bX) / det
+		b := (p.aX*p.goalY - p.aY*p.goalX) / det
+
+		x := a*p.aX + b*p.bX
+		y := a*p.aY + b*p.bY
+		if x == p.goalX && y == p.goalY {
+			sum += 3*a + b
 		}
 	}
 
-	return -1
+	return fmt.Sprintf("Cost is %d tokens to solve these %d claw machines", sum, len(problems))
 }

solutions/day13/parse.go

@@ -20,6 +20,7 @@ var r = regexp.MustCompile(`Button A: X\+(\d+), Y\+(\d+)\nButton B: X\+(\d+), Y\
 
 func parseProblems(
 	input string,
+	part2 bool,
 ) ([]problem, error) {
 	matches := r.FindAllSubmatch([]byte(input), -1)
 	problems := make([]problem, len(matches))
@@ -42,13 +43,20 @@ func parseProblems(
 			digits[j] = d
 		}
 
+		goalX := digits[4]
+		goalY := digits[5]
+		if part2 {
+			goalX += 10000000000000
+			goalY += 10000000000000
+		}
+
 		problems[i] = problem{
 			aX:    digits[0],
 			aY:    digits[1],
 			bX:    digits[2],
 			bY:    digits[3],
-			goalX: digits[4],
-			goalY: digits[5],
+			goalX: goalX,
+			goalY: goalY,
 		}
 	}