feat: solve day 10 part 2
This commit is contained in:
Stevan Freeborn
@@ -19,7 +19,7 @@ func (b button) String() string {
|
||||
return fmt.Sprintf("%v", b.switches)
|
||||
}
|
||||
|
||||
func From(line string) button {
|
||||
func From(line string) Button {
|
||||
buttonRegex := regexp.MustCompile(`\d+`)
|
||||
matches := buttonRegex.FindAllString(line, -1)
|
||||
|
||||
|
||||
+146
-198
@@ -4,11 +4,12 @@ package machine
|
||||
import (
|
||||
"math"
|
||||
"regexp"
|
||||
"slices"
|
||||
"sort"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
"github.com/StevanFreeborn/advent-of-code-2025/cmd/10/button"
|
||||
"github.com/StevanFreeborn/advent-of-code-2025/internal/stack"
|
||||
)
|
||||
|
||||
type Machine interface {
|
||||
@@ -66,263 +67,210 @@ func From(line string) Machine {
|
||||
}
|
||||
|
||||
func (m machine) ConfigureLights() int {
|
||||
combinations := [][]bool{}
|
||||
combs := m.generateCombinations(len(m.desiredLightState))
|
||||
|
||||
minPresses := math.MaxInt
|
||||
numberOfButtons := len(m.buttons)
|
||||
numberOfCombinations := int(math.Pow(2, float64(numberOfButtons)))
|
||||
currentCombination := make([]bool, numberOfButtons)
|
||||
found := false
|
||||
|
||||
for range numberOfCombinations {
|
||||
temp := make([]bool, numberOfButtons)
|
||||
copy(temp, currentCombination)
|
||||
for _, comb := range combs {
|
||||
matches := true
|
||||
|
||||
combinations = append(combinations, temp)
|
||||
for i, count := range comb.deltas {
|
||||
isLightOn := count%2 != 0
|
||||
|
||||
for j := range numberOfButtons {
|
||||
if currentCombination[j] == false {
|
||||
currentCombination[j] = true
|
||||
if isLightOn != m.desiredLightState[i] {
|
||||
matches = false
|
||||
break
|
||||
} else {
|
||||
currentCombination[j] = false
|
||||
}
|
||||
}
|
||||
|
||||
if matches {
|
||||
if comb.numPresses < minPresses {
|
||||
minPresses = comb.numPresses
|
||||
found = true
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for _, currentCombination := range combinations {
|
||||
currentPresses := 0
|
||||
initialLightState := make([]bool, len(m.desiredLightState))
|
||||
|
||||
for bi, bs := range currentCombination {
|
||||
if bs == false {
|
||||
continue
|
||||
}
|
||||
|
||||
currentPresses++
|
||||
switchesToToggle := m.buttons[bi].Switches()
|
||||
|
||||
for _, switchToToggle := range switchesToToggle {
|
||||
initialLightState[switchToToggle] = !initialLightState[switchToToggle]
|
||||
}
|
||||
}
|
||||
|
||||
if slices.Equal(initialLightState, m.desiredLightState) == false {
|
||||
continue
|
||||
}
|
||||
|
||||
if currentPresses < minPresses {
|
||||
minPresses = currentPresses
|
||||
}
|
||||
if found == false {
|
||||
return 0
|
||||
}
|
||||
|
||||
return minPresses
|
||||
}
|
||||
|
||||
type combination struct {
|
||||
deltas []int
|
||||
numPresses int
|
||||
}
|
||||
|
||||
type searchState struct {
|
||||
goal []int
|
||||
currentCost int
|
||||
weight int
|
||||
}
|
||||
|
||||
// If a target is odd I must press a combination of
|
||||
// buttons that contributes an odd value to the target.
|
||||
// This means I can pre-compute what all combinations
|
||||
// of buttons do when pressed exactly once.
|
||||
// I then can look for a combination that matches the
|
||||
// odd/even pattern of the target
|
||||
// When I find a match I can subtract it from the target
|
||||
// and then divide the target by 2 to get a new target
|
||||
// I repeat this until I reach a target of all zeros
|
||||
|
||||
// i.e. Goal: [13, 7]
|
||||
// Button A: [1, 0]
|
||||
// Button B: [1, 1]
|
||||
//
|
||||
// Combinations:
|
||||
// 0 presses: [0, 0]
|
||||
// 1 press: [1, 0] (A)
|
||||
// 1 press: [1, 1] (B)
|
||||
// 1 press: [2, 1] (A, B)
|
||||
//
|
||||
// 1st iteration:
|
||||
// Target: [13, 7] (odd, odd)
|
||||
// Match: [1, 1] (B)
|
||||
// New Target: [(13-1)/2, (7-1)/2] = [6, 3]
|
||||
// Presses: 1 * weight 1 = 1
|
||||
//
|
||||
// Second iteration:
|
||||
// Target: [6, 3] (even, odd)
|
||||
// Match: [2, 1] (A, B)
|
||||
// New Target: [(6-2)/2, (3-1)/2] = [2, 1]
|
||||
// Presses: 2 * weight 2 = 4
|
||||
//
|
||||
// Third iteration:
|
||||
// Target: [2, 1] (even, odd)
|
||||
// Match: [2, 1] (A, B)
|
||||
// New Target: [(2-1)/2, (1-0)/2] = [0, 0]
|
||||
// Presses: 2 * weight 4 = 8
|
||||
//
|
||||
// Total presses: 1 + 4 + 8 = 13
|
||||
func (m machine) ConfigureJoltages() int {
|
||||
matrix := m.createMatrix()
|
||||
combinations := m.generateCombinations(len(m.desiredJoltages))
|
||||
|
||||
eliminated := performGaussianElimination(matrix)
|
||||
pivots, freeVars := analyzeMatrix(eliminated)
|
||||
sort.Slice(combinations, func(i, j int) bool {
|
||||
return combinations[i].numPresses < combinations[j].numPresses
|
||||
})
|
||||
|
||||
numVars := len(matrix[0]) - 1
|
||||
values := make([]int, numVars)
|
||||
bestSolution := Solution{sum: math.MaxInt}
|
||||
stack := stack.New[searchState]()
|
||||
stack.Push(searchState{
|
||||
goal: m.desiredJoltages,
|
||||
currentCost: 0,
|
||||
weight: 1,
|
||||
})
|
||||
|
||||
iterativeSearch(freeVars, pivots, eliminated, values, &bestSolution)
|
||||
minTotalCost := math.MaxInt
|
||||
foundSolution := false
|
||||
|
||||
return bestSolution.sum
|
||||
for stack.IsEmpty() == false {
|
||||
curr, _ := stack.Pop()
|
||||
|
||||
if curr.currentCost >= minTotalCost {
|
||||
continue
|
||||
}
|
||||
|
||||
type Solution struct {
|
||||
values []int
|
||||
sum int
|
||||
found bool
|
||||
if isZero(curr.goal) {
|
||||
if curr.currentCost < minTotalCost {
|
||||
minTotalCost = curr.currentCost
|
||||
foundSolution = true
|
||||
}
|
||||
|
||||
func (m machine) createMatrix() [][]float64 {
|
||||
rows := len(m.desiredJoltages)
|
||||
cols := len(m.buttons)
|
||||
matrix := make([][]float64, rows)
|
||||
|
||||
for r := range rows {
|
||||
matrix[r] = make([]float64, cols+1)
|
||||
|
||||
for i, b := range m.buttons {
|
||||
for _, sw := range b.Switches() {
|
||||
if sw == r {
|
||||
matrix[r][i] = 1
|
||||
}
|
||||
}
|
||||
continue
|
||||
}
|
||||
|
||||
matrix[r][cols] = float64(m.desiredJoltages[r])
|
||||
for _, combination := range combinations {
|
||||
if smallerOrEqual(combination.deltas, curr.goal) == false {
|
||||
continue
|
||||
}
|
||||
|
||||
return matrix
|
||||
if hasSameParity(combination.deltas, curr.goal) == false {
|
||||
continue
|
||||
}
|
||||
|
||||
func performGaussianElimination(m [][]float64) [][]float64 {
|
||||
rows := len(m)
|
||||
cols := len(m[0])
|
||||
pivotColumn := 0
|
||||
nextGoal := make([]int, len(curr.goal))
|
||||
|
||||
mCopy := make([][]float64, rows)
|
||||
|
||||
for i := range rows {
|
||||
mCopy[i] = make([]float64, cols)
|
||||
copy(mCopy[i], m[i])
|
||||
for i := 0; i < len(curr.goal); i++ {
|
||||
nextGoal[i] = (curr.goal[i] - combination.deltas[i]) / 2
|
||||
}
|
||||
|
||||
for r1 := range rows {
|
||||
if cols <= pivotColumn {
|
||||
return mCopy
|
||||
}
|
||||
stepCost := combination.numPresses * curr.weight
|
||||
|
||||
currentRow := r1
|
||||
|
||||
for mCopy[currentRow][pivotColumn] == 0 {
|
||||
currentRow++
|
||||
|
||||
if rows == currentRow {
|
||||
currentRow = r1
|
||||
pivotColumn++
|
||||
|
||||
if cols == pivotColumn {
|
||||
return mCopy
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
mCopy[currentRow], mCopy[r1] = mCopy[r1], mCopy[currentRow]
|
||||
|
||||
pivotValue := mCopy[r1][pivotColumn]
|
||||
|
||||
if pivotValue != 0 {
|
||||
for j := range cols {
|
||||
mCopy[r1][j] /= pivotValue
|
||||
stack.Push(searchState{
|
||||
goal: nextGoal,
|
||||
currentCost: curr.currentCost + stepCost,
|
||||
weight: curr.weight * 2,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
for r2 := range rows {
|
||||
if r2 != r1 {
|
||||
factor := mCopy[r2][pivotColumn]
|
||||
|
||||
for col := range cols {
|
||||
mCopy[r2][col] -= factor * mCopy[r1][col]
|
||||
}
|
||||
}
|
||||
if foundSolution == false {
|
||||
return 0
|
||||
}
|
||||
|
||||
pivotColumn++
|
||||
return minTotalCost
|
||||
}
|
||||
|
||||
return mCopy
|
||||
}
|
||||
func (m machine) generateCombinations(size int) []combination {
|
||||
res := []combination{{
|
||||
deltas: make([]int, size),
|
||||
numPresses: 0,
|
||||
}}
|
||||
|
||||
func analyzeMatrix(m [][]float64) (map[int]int, []int) {
|
||||
pivots := make(map[int]int)
|
||||
for _, btn := range m.buttons {
|
||||
currentCount := len(res)
|
||||
|
||||
cols := len(m[0])
|
||||
numVars := cols - 1
|
||||
for i := range currentCount {
|
||||
existing := res[i]
|
||||
|
||||
isFree := make([]bool, numVars)
|
||||
newDeltas := make([]int, size)
|
||||
copy(newDeltas, existing.deltas)
|
||||
|
||||
for i := range isFree {
|
||||
isFree[i] = true
|
||||
}
|
||||
|
||||
rows := len(m)
|
||||
|
||||
for r := range rows {
|
||||
for c := 0; c < cols-1; c++ {
|
||||
if math.Abs(m[r][c]-1.0) < 1e-9 {
|
||||
pivots[c] = r
|
||||
isFree[c] = false
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
freeVars := []int{}
|
||||
|
||||
for i, free := range isFree {
|
||||
if free {
|
||||
freeVars = append(freeVars, i)
|
||||
for _, switchIdx := range btn.Switches() {
|
||||
if switchIdx < size {
|
||||
newDeltas[switchIdx]++
|
||||
}
|
||||
}
|
||||
|
||||
return pivots, freeVars
|
||||
}
|
||||
|
||||
func iterativeSearch(freeVars []int, pivots map[int]int, matrix [][]float64, values []int, best *Solution) {
|
||||
if len(freeVars) == 0 {
|
||||
evaluateSolution(pivots, matrix, values, best)
|
||||
return
|
||||
}
|
||||
|
||||
counters := make([]int, len(freeVars))
|
||||
limit := 250
|
||||
|
||||
for {
|
||||
for i, counterVal := range counters {
|
||||
values[freeVars[i]] = counterVal
|
||||
}
|
||||
|
||||
evaluateSolution(pivots, matrix, values, best)
|
||||
|
||||
idx := len(counters) - 1
|
||||
|
||||
for idx >= 0 {
|
||||
counters[idx]++
|
||||
|
||||
if counters[idx] > limit {
|
||||
counters[idx] = 0
|
||||
idx--
|
||||
} else {
|
||||
break
|
||||
res = append(res, combination{
|
||||
deltas: newDeltas,
|
||||
numPresses: existing.numPresses + 1,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
if idx < 0 {
|
||||
break
|
||||
return res
|
||||
}
|
||||
|
||||
func isZero(arr []int) bool {
|
||||
for _, v := range arr {
|
||||
if v != 0 {
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
func evaluateSolution(pivots map[int]int, m [][]float64, values []int, best *Solution) {
|
||||
isValid := true
|
||||
currentSum := 0
|
||||
cols := len(m[0])
|
||||
return true
|
||||
}
|
||||
|
||||
for col, row := range pivots {
|
||||
sum := m[row][cols-1]
|
||||
|
||||
for c := 0; c < cols-1; c++ {
|
||||
if c != col {
|
||||
coeff := m[row][c]
|
||||
sum -= coeff * float64(values[c])
|
||||
func smallerOrEqual(a []int, b []int) bool {
|
||||
for i := range a {
|
||||
if a[i] > b[i] {
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
values[col] = int(math.Round(sum))
|
||||
return true
|
||||
}
|
||||
|
||||
for _, v := range values {
|
||||
if v < 0 {
|
||||
isValid = false
|
||||
break
|
||||
func hasSameParity(a []int, b []int) bool {
|
||||
for i := range a {
|
||||
if a[i]%2 != b[i]%2 {
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
currentSum += v
|
||||
}
|
||||
|
||||
if isValid {
|
||||
if currentSum < best.sum {
|
||||
best.sum = currentSum
|
||||
|
||||
best.values = make([]int, len(values))
|
||||
copy(best.values, values)
|
||||
|
||||
best.found = true
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
+1
-1
@@ -37,7 +37,7 @@ func TestSolvePartTwoWithExampleInput(t *testing.T) {
|
||||
}
|
||||
|
||||
func TestSolvePartTwoWithInput(t *testing.T) {
|
||||
expected := -1
|
||||
expected := 19810
|
||||
|
||||
result := solution.SolvePartTwo("INPUT.txt")
|
||||
|
||||
|
||||
@@ -1,143 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
const (
|
||||
Reset = "\033[0m"
|
||||
Red = "\033[31m"
|
||||
Green = "\033[32m"
|
||||
Yellow = "\033[33m"
|
||||
Blue = "\033[34m"
|
||||
White = "\033[37m"
|
||||
Gray = "\033[90m"
|
||||
Clear = "\033[H\033[2J"
|
||||
)
|
||||
|
||||
type Solution struct {
|
||||
a, b, c, d, e, f int
|
||||
sum int
|
||||
found bool
|
||||
}
|
||||
|
||||
func main() {
|
||||
best := Solution{sum: 99999}
|
||||
delay := 150 * time.Millisecond
|
||||
|
||||
for f := 0; f <= 5; f++ {
|
||||
for d := 0; d <= 7; d++ {
|
||||
|
||||
a := 2 - d + f
|
||||
b := 5 - f
|
||||
c := 4 - d - f
|
||||
e := 3 - f
|
||||
|
||||
currentSum := a + b + c + d + e + f
|
||||
|
||||
validA := a >= 0
|
||||
validB := b >= 0
|
||||
validC := c >= 0
|
||||
validE := e >= 0
|
||||
|
||||
isSolution := validA && validB && validC && validE
|
||||
|
||||
isNewBest := false
|
||||
|
||||
if isSolution {
|
||||
if currentSum < best.sum {
|
||||
best = Solution{a, b, c, d, e, f, currentSum, true}
|
||||
isNewBest = true
|
||||
}
|
||||
}
|
||||
|
||||
printDashboard(d, f, a, b, c, e, currentSum, best, isSolution)
|
||||
|
||||
if isNewBest {
|
||||
time.Sleep(1 * time.Second)
|
||||
} else {
|
||||
time.Sleep(delay)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
printFinalResult(best)
|
||||
}
|
||||
|
||||
func printDashboard(d, f, a, b, c, e, sum int, best Solution, valid bool) {
|
||||
var sb strings.Builder
|
||||
|
||||
sb.WriteString(Clear)
|
||||
|
||||
sb.WriteString(fmt.Sprintf(" %sFREE VARIABLES%s\n", Yellow, Reset))
|
||||
sb.WriteString(" ────────────────────────────────────────\n")
|
||||
sb.WriteString(fmt.Sprintf(" INPUT d: %s%-3d%s %s\n", White, d, Reset, bar(d, 7)))
|
||||
sb.WriteString(fmt.Sprintf(" INPUT f: %s%-3d%s %s\n\n", White, f, Reset, bar(f, 7)))
|
||||
|
||||
sb.WriteString(fmt.Sprintf(" %sDEPENDENT VARIABLES%s\n", Yellow, Reset))
|
||||
sb.WriteString(" ────────────────────────────────────────\n")
|
||||
sb.WriteString(formatVar("a", "2 - d + f", a))
|
||||
sb.WriteString(formatVar("b", "5 - f", b))
|
||||
sb.WriteString(formatVar("c", "4 - d - f", c))
|
||||
sb.WriteString(formatVar("e", "3 - f", e))
|
||||
|
||||
sb.WriteString("\n")
|
||||
|
||||
sb.WriteString(fmt.Sprintf(" %sSTATUS%s\n", Yellow, Reset))
|
||||
sb.WriteString(" ────────────────────────────────────────\n")
|
||||
|
||||
statusColor := Red
|
||||
statusText := "INVALID (Constraints Failed)"
|
||||
|
||||
if valid {
|
||||
statusColor = Green
|
||||
statusText = "VALID SOLUTION"
|
||||
}
|
||||
|
||||
sb.WriteString(fmt.Sprintf(" Current Sum: %d\n", sum))
|
||||
sb.WriteString(fmt.Sprintf(" Constraint Check: %s%s%s\n\n", statusColor, statusText, Reset))
|
||||
|
||||
sb.WriteString(fmt.Sprintf(" %sBEST MINIMUM FOUND SO FAR%s\n", Yellow, Reset))
|
||||
sb.WriteString(" ────────────────────────────────────────\n")
|
||||
|
||||
if best.found {
|
||||
sb.WriteString(fmt.Sprintf(" Total Sum: %s%d%s\n", Green, best.sum, Reset))
|
||||
sb.WriteString(fmt.Sprintf(" Values: a=%d, b=%d, c=%d, d=%d, e=%d, f=%d\n", best.a, best.b, best.c, best.d, best.e, best.f))
|
||||
} else {
|
||||
sb.WriteString(" Searching...\n")
|
||||
}
|
||||
|
||||
fmt.Print(sb.String())
|
||||
}
|
||||
|
||||
func formatVar(name, eq string, val int) string {
|
||||
color := Green
|
||||
check := "OK"
|
||||
|
||||
if val < 0 {
|
||||
color = Red
|
||||
check = "FAIL (< 0)"
|
||||
}
|
||||
|
||||
displayVal := max(val, 0)
|
||||
visual := bar(displayVal, 10)
|
||||
|
||||
return fmt.Sprintf(" %s = %-10s = %s%-3d%s [%-10s] %s\n", name, eq, color, val, Reset, check, visual)
|
||||
}
|
||||
|
||||
func bar(val, max int) string {
|
||||
if val < 0 {
|
||||
val = 0
|
||||
}
|
||||
if val > max {
|
||||
val = max
|
||||
}
|
||||
return "[" + strings.Repeat("█", val) + strings.Repeat("░", max-val) + "]"
|
||||
}
|
||||
|
||||
func printFinalResult(s Solution) {
|
||||
fmt.Printf("Smallest Total Possible: %s%d%s\n", Green, s.sum, Reset)
|
||||
fmt.Printf("Configuration: a=%d, b=%d, c=%d, d=%d, e=%d, f=%d\n", s.a, s.b, s.c, s.d, s.e, s.f)
|
||||
}
|
||||
Reference in New Issue
Block a user