2023 day 08

2023/08/part1/cmd/main.go

@@ -0,0 +1,39 @@
+
+package main
+
+import (
+	"bufio"
+	"os"
+	"fmt"
+	"git.tristans.cloud/tristan/aoc/2023/08/part1/part1"
+	"strings"
+)
+
+func main() {
+	reader := bufio.NewReader(os.Stdin);
+	ins, err := reader.ReadString('\n');
+	if err != nil {
+		fmt.Println("Halted too soon!")
+		return
+	}
+	ins = strings.Trim(ins, "\n")
+	_, err = reader.ReadString('\n');
+	if err != nil {
+		fmt.Println("Halted too soon!")
+		return
+	}
+	net := part1.Network{}
+	for {
+		line, err := reader.ReadString('\n');
+		if err != nil {
+			break
+		}
+		part1.AddToNet(net, line)
+	}
+	steps, err := part1.StepsToSolve(ins, net)
+	if (err != nil) {
+		fmt.Println(err)
+	}
+	fmt.Println(steps)
+}
+

2023/08/part1/part1/part1.go

@@ -0,0 +1,55 @@
+
+package part1
+
+import (
+	"regexp"
+	"errors"
+	"fmt"
+)
+
+type Network = map[string][2]string
+const start = "AAA"
+const Goal = "ZZZ"
+
+func GetValues(in string) (src, left, right string, err error) {
+	re := regexp.MustCompile(`[A-Z1-9]{3}`)
+	out := re.FindAllString(in, -1)
+	if (len(out) != 3) {
+		return "", "", "", errors.New("must be three values")
+	}
+	src = out[0];
+	left = out[1];
+	right = out[2];
+	return
+}
+
+func AddToNet(net Network, line string) error {
+	src, left, right, err := GetValues(line)
+	if err != nil {
+		return err
+	}
+	net[src] = [2]string{left, right}
+	return nil
+}
+
+func StepsToSolve(ins string, net Network) (int, error) {
+	current := start;
+	steps := 0;
+	i := 0
+	for {
+		if current == Goal {
+			return steps, nil
+		}
+		steps ++
+		switch ins[i  % len(ins)] {
+		case 'L':
+			current = net[current][0]
+		case 'R':
+			current = net[current][1]
+		default:
+			return 0, fmt.Errorf("instructions unclear! Must only be 'R' and 'L', but got %v at [%v]", ins[i], i)
+		}
+		i++
+	}
+}
+

2023/08/part1/part1/part1_test.go

@@ -0,0 +1,58 @@
+
+package part1
+
+import (
+	"testing"
+	"reflect"
+)
+
+func TestGetValues(t *testing.T) {
+	src, left, right, err := GetValues("AAA = (BBB, CCC)\n")
+	equal(t, err, nil)
+	equal(t, src, "AAA")
+	equal(t, left, "BBB")
+	equal(t, right, "CCC")
+}
+
+func TestAddToNet(t *testing.T) {
+	net := Network{}
+	err := AddToNet(net, "AAA = (BBB, CCC)")
+	equal(t, err, nil)
+	equal(t, net["AAA"], [2]string{"BBB","CCC"})
+}
+
+func TestStepsToSolveWithBadDirections(t *testing.T) {
+	_, err := StepsToSolve("AB", Network{})
+	if err == nil {
+		t.Errorf("wanted an error")
+	}
+}
+
+func TestStepsToSolve(t *testing.T) {
+	net := Network{
+		"AAA": [2]string{"BBB","CCC"},
+		"CCC": [2]string{"ZZZ","AAA"},
+		"ZZZ": [2]string{"ZZZ","ZZZ"},
+	}
+	steps, err := StepsToSolve("RL", net)
+	equal(t, err, nil)
+	equal(t, steps, 2)
+}
+
+func TestStepsToSolveWithLoop(t *testing.T) {
+	net := Network{
+		"AAA": [2]string{"BBB","BBB"},
+		"BBB": [2]string{"AAA","ZZZ"},
+		"ZZZ": [2]string{"ZZZ","ZZZ"},
+	}
+	steps, err := StepsToSolve("LLR", net)
+	equal(t, err, nil)
+	equal(t, steps, 6)
+}
+
+func equal(t *testing.T, actual any, target any) {
+	if !reflect.DeepEqual(actual, target) {
+		t.Errorf("expected '%v', got '%v'", target, actual)
+	}
+}
+