feat: wip on day 10 part 2

cmd/10/machine/machine.go

@@ -2,7 +2,6 @@
 package machine
 
 import (
-	"fmt"
 	"math"
 	"regexp"
 	"slices"
@@ -119,49 +118,211 @@ func (m machine) ConfigureLights() int {
 }
 
 func (m machine) ConfigureJoltages() int {
-	minPresses := 0
-	// counters := make([]int, len(m.joltageSettings))
+	matrix := m.createMatrix()
 
-	// given the target joltage of a counter
-	// how many times can I press a particular button
-	// before making one of the counters that the button
-	// affects invalid
-	// 3,5,4,7
-	// 0 (3)
-	// 1 (1,3)
-	// 2 (2)
-	// 3 (2,3)
-	// 4 (0,2)
-	// 5 (0,1)
+	eliminated := performGaussianElimination(matrix)
+	pivots, freeVars := analyzeMatrix(eliminated)
 
-	// (0n * 1) + (1n * 0) + (1n * 1) + (3n * 1) = 7
-	// 2n + 3n + 4n = 4
+	numVars := len(matrix[0]) - 1
+	values := make([]int, numVars)
+	bestSolution := Solution{sum: math.MaxInt}
 
-	// TODO: I need to use Gausian elimination
-	// to solve this
-	// TODO: Or matrix method maybe?
+	iterativeSearch(freeVars, pivots, eliminated, values, &bestSolution)
 
+	return bestSolution.sum
+}
+
+type Solution struct {
+	values []int
+	sum    int
+	found  bool
+}
+
+func (m machine) createMatrix() [][]float64 {
 	rows := len(m.desiredJoltages)
 	cols := len(m.buttons)
-	grid := make([][]int, rows)
+	matrix := make([][]float64, rows)
 
 	for r := range rows {
-		grid[r] = make([]int, cols+1)
+		matrix[r] = make([]float64, cols+1)
 
 		for i, b := range m.buttons {
 			for _, sw := range b.Switches() {
 				if sw == r {
-					grid[r][i] = 1
+					matrix[r][i] = 1
 				}
 			}
 		}
 
-		grid[r][cols] = m.desiredJoltages[r]
-
-		fmt.Println(grid[r])
+		matrix[r][cols] = float64(m.desiredJoltages[r])
 	}
 
-	fmt.Println()
+	return matrix
+}
 
-	return minPresses
+func performGaussianElimination(m [][]float64) [][]float64 {
+	rows := len(m)
+	cols := len(m[0])
+	pivotColumn := 0
+
+	mCopy := make([][]float64, rows)
+
+	for i := range rows {
+		mCopy[i] = make([]float64, cols)
+		copy(mCopy[i], m[i])
+	}
+
+	for r1 := range rows {
+		if cols <= pivotColumn {
+			return mCopy
+		}
+
+		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
+			}
+		}
+
+		for r2 := range rows {
+			if r2 != r1 {
+				factor := mCopy[r2][pivotColumn]
+
+				for col := range cols {
+					mCopy[r2][col] -= factor * mCopy[r1][col]
+				}
+			}
+		}
+
+		pivotColumn++
+	}
+
+	return mCopy
+}
+
+func analyzeMatrix(m [][]float64) (map[int]int, []int) {
+	pivots := make(map[int]int)
+
+	cols := len(m[0])
+	numVars := cols - 1
+
+	isFree := make([]bool, numVars)
+
+	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)
+		}
+	}
+
+	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
+			}
+		}
+
+		if idx < 0 {
+			break
+		}
+	}
+}
+
+func evaluateSolution(pivots map[int]int, m [][]float64, values []int, best *Solution) {
+	isValid := true
+	currentSum := 0
+	cols := len(m[0])
+
+	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])
+			}
+		}
+
+		values[col] = int(math.Round(sum))
+	}
+
+	for _, v := range values {
+		if v < 0 {
+			isValid = false
+			break
+		}
+
+		currentSum += v
+	}
+
+	if isValid {
+		if currentSum < best.sum {
+			best.sum = currentSum
+
+			best.values = make([]int, len(values))
+			copy(best.values, values)
+
+			best.found = true
+		}
+	}
 }