Solution for 2024, day 24

Author: lucianoq

2024/24/Makefile

@@ -0,0 +1,20 @@
+input:
+	http "https://adventofcode.com/2024/day/24/input" "Cookie:session=${AOC_SESSION};" >input
+
+main1:
+	go build -o main1 main1.go common.go
+
+main2:
+	go build -o main2 main2.go common.go
+
+.PHONY: run1 run2 clean
+
+run1: main1 input
+	./main1 <input
+
+run2: main2 input
+	./main2 <input
+
+clean:
+	rm -f main1 main2 input
+

2024/24/common.go

@@ -0,0 +1,69 @@
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"strings"
+)
+
+type Rule struct {
+	Left, Op, Right string
+}
+
+func parseInput() (map[string]bool, map[string]Rule) {
+	var facts = map[string]bool{}
+	scanner := bufio.NewScanner(os.Stdin)
+	for scanner.Scan() {
+		line := scanner.Text()
+		if line == "" {
+			break
+		}
+		ff := strings.Split(line, ": ")
+		facts[ff[0]] = ff[1] == "1"
+	}
+
+	var rules = map[string]Rule{}
+	for scanner.Scan() {
+		ff := strings.Fields(scanner.Text())
+		rules[ff[4]] = Rule{ff[0], ff[1], ff[2]}
+	}
+
+	return facts, rules
+}
+
+func GetNumber(letter string, facts map[string]bool, rules map[string]Rule) int {
+	var z int
+	for i := 63; i >= 0; i-- {
+		if solve(fmt.Sprintf("%s%02d", letter, i), facts, rules) {
+			z |= 1 << i
+		}
+	}
+	return z
+}
+
+func solve(target string, facts map[string]bool, rules map[string]Rule) bool {
+	if v, ok := facts[target]; ok {
+		return v
+	}
+
+	rule, ok := rules[target]
+	if !ok {
+		return false
+	}
+
+	left := solve(rule.Left, facts, rules)
+	right := solve(rule.Right, facts, rules)
+
+	var result bool
+	switch rule.Op {
+	case "AND":
+		result = left && right
+	case "OR":
+		result = left || right
+	case "XOR":
+		result = left != right
+	}
+	facts[target] = result
+	return result
+}

2024/24/main1.go

@@ -0,0 +1,9 @@
+package main
+
+import "fmt"
+
+func main() {
+	facts, rules := parseInput()
+	z := GetNumber("z", facts, rules)
+	fmt.Println(z)
+}

2024/24/main2.go

@@ -0,0 +1,108 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"sort"
+	"strings"
+)
+
+func main() {
+	facts, rules := parseInput()
+
+	// GenerateDot(rules)
+	// return
+
+	// After generating the dot file, I could generate an image with
+	//
+	//   dot -Tpng -O graph.dot
+	//
+	// and thanks to the colors of the arrows, it was easy to spot inconsistencies.
+	// E.g.
+	//   All zXX were reached by two red arrows (a XOR operation).
+	//   `z13` was reached by two green, meaning it needed to be swapped with a node
+	//      that is reached by two red arrows instead of green.
+	//   `z19` and `z33` were incorrectly blue.
+	//
+	// The full list was:
+	// - z13 green (supposed red)
+	// - z19 blue (supposed red)
+	// - z33 blue (supposed red)
+	// - gws blue (supposed red)
+	// - hgj red (supposed blue)
+	// - npf red (supposed green)
+	// - nnt red (supposed blue)
+	// - cph red (supposed blue)
+
+	list := []string{"z13", "z19", "z33", "npf", "hgj", "gws", "nnt", "cph"}
+	sort.Strings(list)
+	fmt.Println(strings.Join(list, ","))
+
+	return
+
+	// The assignment didn't ask to fix the gates (so the list above is enough
+	// to generate the solution:
+	//
+	// Anyway it's pretty easy to spot the pairs:
+	// - z13 <> npf  (the only green/red pair)
+	// - gws <> nnt  (they are both in the z09 area: a different swap would change the graph massively)
+	// - z19 <> cph  (they are both in the z19 area)
+	// - z33 <> hgj  (they are both in the z33 area)
+
+	swap("z13", "npf", rules)
+	swap("z33", "hgj", rules)
+	swap("gws", "nnt", rules)
+	swap("z19", "cph", rules)
+	x := GetNumber("x", facts, rules)
+	y := GetNumber("y", facts, rules)
+	z := GetNumber("z", facts, rules)
+	fmt.Printf("  x: %d +\n  y: %d =\nx+y: %d\n  z: %d\n", x, y, x+y, z)
+	fmt.Printf("Sum is working = %t\n", x+y == z)
+
+	//   x: 22423510084409 +
+	//   y: 19634559019535 =
+	// x+y: 42058069103944
+	//   z: 42058069103944
+	// Sum is working = true
+}
+
+func swap(r1, r2 string, rules map[string]Rule) {
+	rules[r1], rules[r2] = rules[r2], rules[r1]
+}
+
+func GenerateDot(rules map[string]Rule) {
+	f, err := os.Create("graph.dot")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer f.Close()
+
+	const Size = 45
+	fmt.Fprint(f, "digraph {\n")
+	for rName, r := range rules {
+		var color string
+		switch r.Op {
+		case "XOR":
+			color = "red"
+		case "AND":
+			color = "blue"
+		case "OR":
+			color = "green"
+		}
+
+		fmt.Fprintf(f, "%s -> %s [color=\"%s\"];\n", r.Left, rName, color)
+		fmt.Fprintf(f, "%s -> %s [color=\"%s\"];\n", r.Right, rName, color)
+	}
+
+	var xs, ys, zs []string
+	for i := 0; i < Size; i++ {
+		xs = append(xs, fmt.Sprintf("x%02d", i))
+		ys = append(ys, fmt.Sprintf("y%02d", i))
+		zs = append(zs, fmt.Sprintf("z%02d", i))
+	}
+	fmt.Fprintf(f, "{rank = min;\n %s ; \n};\n", strings.Join(xs, " -> "))
+	fmt.Fprintf(f, "{rank = min;\n %s ; \n};\n", strings.Join(ys, " -> "))
+	fmt.Fprintf(f, "{rank = max;\n %s ; \n};\n", strings.Join(zs, " -> "))
+	fmt.Fprint(f, "}\n")
+}