Refactor day13 solution to use int64

Author: terminalnode

solutions/day13/main.go

@@ -3,7 +3,6 @@ package main
 import (
 	"fmt"
 	"github.com/terminalnode/adventofcode2024/common"
-	"github.com/terminalnode/adventofcode2024/common/util"
 	"log"
 	"math"
 )
@@ -20,7 +19,7 @@ func part1(
 		return fmt.Sprintf("Failed to parse input: %v", err)
 	}
 
-	sum := 0
+	sum := int64(0)
 	for _, p := range problems {
 		minTokenCost := findMinTokenCost(p)
 		if minTokenCost != -1 {
@@ -33,45 +32,42 @@ func part1(
 
 func findMinTokenCost(
 	p problem,
-) int {
-	smallest := math.MaxInt
+) int64 {
+	smallest := int64(math.MaxInt64)
 
-	for timesA := 0; true; timesA++ {
-		c := util.Coordinate{
-			X: timesA * p.a.X,
-			Y: timesA * p.a.Y,
-		}
-		if c.X > p.goal.X || c.Y > p.goal.Y {
+	for timesA := int64(0); true; timesA++ {
+		cX := timesA * p.aX
+		cY := timesA * p.aY
+		if cX > p.goalX || cY > p.goalY {
 			break
 		}
 
-		minMoves := findMinTokenCostAfterA(c, timesA, p)
+		minMoves := findMinTokenCostAfterA(cX, cY, timesA, p)
 		if minMoves != -1 && minMoves < smallest {
 			log.Printf("New smallest! %d", minMoves)
 			smallest = minMoves
 		}
 	}
 
-	if smallest == math.MaxInt {
+	if smallest == math.MaxInt64 {
 		return -1
 	}
 	return smallest
 }
 
 func findMinTokenCostAfterA(
-	c util.Coordinate,
-	timesA int,
+	cX int64,
+	cY int64,
+	timesA int64,
 	p problem,
-) int {
-	for timesB := 0; true; timesB++ {
-		newC := util.Coordinate{
-			X: timesB*p.b.X + c.X,
-			Y: timesB*p.b.Y + c.Y,
-		}
+) int64 {
+	for timesB := int64(0); true; timesB++ {
+		newX := timesB*p.bX + cX
+		newY := timesB*p.bY + cY
 
-		if newC.X > p.goal.X || newC.Y > p.goal.Y {
+		if newX > p.goalX || newY > p.goalY {
 			break
-		} else if newC.X == p.goal.X && newC.Y == p.goal.Y {
+		} else if newX == p.goalX && newY == p.goalY {
 			return timesA*3 + timesB
 		}
 	}

solutions/day13/parse.go

@@ -3,15 +3,17 @@ package main
 import (
 	"errors"
 	"fmt"
-	"github.com/terminalnode/adventofcode2024/common/util"
 	"regexp"
 	"strconv"
 )
 
 type problem struct {
-	a    util.Coordinate
-	b    util.Coordinate
-	goal util.Coordinate
+	aX    int64
+	aY    int64
+	bX    int64
+	bY    int64
+	goalX int64
+	goalY int64
 }
 
 var r = regexp.MustCompile(`Button A: X\+(\d+), Y\+(\d+)\nButton B: X\+(\d+), Y\+(\d+)\nPrize: X=(\d+), Y=(\d+)`)
@@ -31,19 +33,22 @@ func parseProblems(
 			return problems, fmt.Errorf("expected match to be at least 7 long, but was %d", len(match))
 		}
 
-		digits := make([]int, 6)
+		digits := make([]int64, 6)
 		for j := 0; j < 6; j++ {
-			d, err := strconv.ParseInt(string(match[j+1]), 10, 0)
+			d, err := strconv.ParseInt(string(match[j+1]), 10, 64)
 			if err != nil {
 				return problems, err
 			}
-			digits[j] = int(d)
+			digits[j] = d
 		}
 
 		problems[i] = problem{
-			a:    util.Coordinate{X: digits[0], Y: digits[1]},
-			b:    util.Coordinate{X: digits[2], Y: digits[3]},
-			goal: util.Coordinate{X: digits[4], Y: digits[5]},
+			aX:    digits[0],
+			aY:    digits[1],
+			bX:    digits[2],
+			bY:    digits[3],
+			goalX: digits[4],
+			goalY: digits[5],
 		}
 	}