Finally solved 2021 day 19

2021/day19/main.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"errors"
 	"fmt"
 	"os"
 	"strings"
@@ -10,44 +11,75 @@ import (
 
 func main() {
 	inp := h.StdinToStringSlice()
-	scanners := parseScanners(inp)
-	part1(scanners)
-}
 
-func part1(scanners []scanner) {
-	foundBeacons := scanners[0].beacons
-	foundScannerPositions := []beacon{{0, 0, 0}}
-
-	remaining := scanners[1:]
-	for len(remaining) > 0 {
-		fmt.Println(len(remaining), "Remaining")
-		var wrk scanner
-		wrk, remaining = remaining[0], remaining[1:]
-		s, err := NewScanner(foundBeacons).getTransformedIfOverlap(wrk)
-		if err != nil {
-			remaining = append(remaining, wrk)
-		} else {
-			foundBeacons = append(foundBeacons, s.beacons...)
-			foundScannerPositions = append(foundScannerPositions, s.position)
-		}
-		fmt.Println("  ", foundBeacons)
-	}
+	ans1, ans2 := solve(inp)
 	fmt.Println("# Part 1")
-	fmt.Println(len(foundScannerPositions))
+	fmt.Println(ans1)
+	fmt.Println()
+	fmt.Println("# Part 2")
+	fmt.Println(ans2)
 }
 
-func parseScanners(inp []string) []scanner {
-	var scanners []scanner
+func solve(input []string) (int, int) {
+	scanners := parseScanners(input)
+
+	solved := []Scanner{scanners[0]}
+	solved[0].absoluteCoords = solved[0].relativeCoords
+	solved[0].fillAbsMap()
+
+	// Scanners with a position we don't know yet
+	unk := scanners[1:]
+	// loop until we know them all
+	for len(unk) > 0 {
+		fmt.Print(h.CLEAR_SCREEN, "Processing...\n")
+		c, t := len(solved), len(scanners)
+		h.PrintProgress(c, t)
+		fmt.Printf(" %d/%d %d%%\n", c, t, int(float64(c)/float64(t)*100))
+
+		for i, undet := range unk {
+			ok := undet.findCoords(solved)
+			if ok {
+				solved = append(solved, undet)
+				// remove the determined scanner from the unknown list
+				copy(unk[i:], unk[i+1:])
+				unk = unk[:len(unk)-1]
+				break
+			}
+		}
+	}
+
+	allBeacons := map[[3]int]bool{}
+	for _, s := range solved {
+		for c := range s.absoluteCoordsMap {
+			allBeacons[c] = true
+		}
+	}
+
+	var furthest int
+	for i, s1 := range solved {
+		for j, s2 := range solved {
+			if i == j {
+				continue
+			}
+			dist := h.Abs(s1.x-s2.x) + h.Abs(s1.y-s2.y) + h.Abs(s1.z-s2.z)
+			if dist > furthest {
+				furthest = dist
+			}
+		}
+	}
+	return len(allBeacons), furthest
+}
+
+func parseScanners(inp []string) []Scanner {
+	var scanners []Scanner
 	for i := range inp {
 		if strings.HasPrefix(inp[i], "---") {
-			// Find the next empty line
 			end := i
 			for ; end < len(inp); end++ {
 				if inp[end] == "" {
 					break
 				}
 			}
-			// a new scanner
 			wrk, err := NewScannerFromInput(inp[i:end])
 			if err == nil {
 				scanners = append(scanners, wrk)
@@ -59,3 +91,127 @@ func parseScanners(inp []string) []scanner {
 	}
 	return scanners
 }
+
+type Scanner struct {
+	number            int
+	x, y, z           int
+	relativeCoords    [][3]int
+	rotations         [][][3]int
+	absoluteCoords    [][3]int
+	absoluteCoordsMap map[[3]int]bool
+}
+
+func NewScannerFromInput(inp []string) (Scanner, error) {
+	s := Scanner{
+		absoluteCoordsMap: make(map[[3]int]bool),
+	}
+	r := strings.NewReader(inp[0])
+	_, err := fmt.Fscanf(r, "--- scanner %d ---", &s.number)
+	if err != nil {
+		return s, errors.New("No Scanner ID")
+	}
+	for _, v := range inp[1:] {
+		var x, y, z int
+		r = strings.NewReader(v)
+		_, err := fmt.Fscanf(r, "%d,%d,%d", &x, &y, &z)
+		if err != nil {
+			return s, err
+		}
+		s.relativeCoords = append(s.relativeCoords, [3]int{x, y, z})
+	}
+	s.fillRotations()
+	return s, nil
+}
+
+func (s *Scanner) fillAbsMap() {
+	s.absoluteCoordsMap = map[[3]int]bool{}
+	if len(s.absoluteCoords) == 0 {
+		panic(fmt.Sprintf("absolute coords not set for scanner %d", s.number))
+	}
+	for _, ac := range s.absoluteCoords {
+		s.absoluteCoordsMap[ac] = true
+	}
+}
+
+// Fill in all coordinates for all beacon rotations
+func (s *Scanner) fillRotations() {
+	dir1 := s.relativeCoords
+	var dir2, dir3, dir4, dir5, dir6 [][3]int
+	for _, c := range dir1 {
+		x, y, z := c[0], c[1], c[2]
+		dir2 = append(dir2, [3]int{x, -y, -z})
+		dir3 = append(dir3, [3]int{x, -z, y})
+		dir4 = append(dir4, [3]int{-y, -z, x})
+		dir5 = append(dir5, [3]int{-x, -z, -y})
+		dir6 = append(dir6, [3]int{y, -z, -x})
+	}
+	sixRotations := [][][3]int{
+		dir1, dir2,
+		dir3, dir4,
+		dir5, dir6,
+	}
+
+	var finalRotations [][][3]int
+	for _, rotation := range sixRotations {
+		var r2, r3, r4 [][3]int
+		for _, c := range rotation {
+			x, y, z := c[0], c[1], c[2]
+			r2 = append(r2, [3]int{-y, x, z})
+			r3 = append(r3, [3]int{-x, -y, z})
+			r4 = append(r4, [3]int{y, -x, z})
+		}
+		finalRotations = append(finalRotations, rotation, r2, r3, r4)
+	}
+	s.rotations = finalRotations
+}
+
+// Find the absolute coordinates for this scanner, if we can.
+func (s *Scanner) findCoords(solved []Scanner) bool {
+	for _, rotatedCoords := range s.rotations {
+		for _, set := range solved {
+			for _, absCoord := range set.absoluteCoords {
+				for _, relativeCoord := range rotatedCoords {
+					unsolvedAbsoluteCoords := fillAbsCoords(absCoord, relativeCoord, rotatedCoords)
+
+					var matchingCount int
+					for _, ac := range unsolvedAbsoluteCoords {
+						if set.absoluteCoordsMap[ac] {
+							matchingCount++
+						}
+					}
+
+					if matchingCount >= 12 {
+						s.relativeCoords = rotatedCoords
+						s.absoluteCoords = unsolvedAbsoluteCoords
+						s.fillAbsMap()
+						s.x = absCoord[0] - relativeCoord[0]
+						s.y = absCoord[1] - relativeCoord[1]
+						s.z = absCoord[2] - relativeCoord[2]
+						return true
+					}
+				}
+			}
+		}
+	}
+	return false
+}
+
+// Assume that absolute and relative are actually the same coordinate, calc the diff of all relative Coords
+func fillAbsCoords(absolute, relative [3]int, relativeCoords [][3]int) [][3]int {
+	diff := [3]int{
+		absolute[0] - relative[0],
+		absolute[1] - relative[1],
+		absolute[2] - relative[2],
+	}
+
+	var absCoords [][3]int
+	for _, c := range relativeCoords {
+		absCoords = append(absCoords, [3]int{
+			diff[0] + c[0],
+			diff[1] + c[1],
+			diff[2] + c[2],
+		})
+	}
+
+	return absCoords
+}