155 lines
3.4 KiB
Go
155 lines
3.4 KiB
Go
package day8
|
|
|
|
import (
|
|
"fmt"
|
|
"log"
|
|
"os"
|
|
"regexp"
|
|
"slices"
|
|
"strings"
|
|
)
|
|
|
|
func Run() int {
|
|
fmt.Print("hello day 8")
|
|
filename := "day8/example3"
|
|
net, path := Read(filename)
|
|
fmt.Printf("got %+v and %+v\n", net, path)
|
|
result := GhostTraverse(net, path)
|
|
return result
|
|
}
|
|
|
|
func GhostTraverse(net Network, path Path) int {
|
|
stepsNum := 0
|
|
simultaneousPaths := make([]Node, 0)
|
|
for nodeName, node := range net.Nodes {
|
|
if strings.HasSuffix(nodeName, "A") {
|
|
simultaneousPaths = append(simultaneousPaths, node)
|
|
}
|
|
}
|
|
log.Printf("collected start points: %+v\n", simultaneousPaths)
|
|
|
|
// concurrent iteraction
|
|
for !isGhostWayDone(simultaneousPaths) {
|
|
direction := path.next()
|
|
for i, curNode := range simultaneousPaths {
|
|
simultaneousPaths[i] = getNextNode(net, curNode, direction)
|
|
}
|
|
// log.Printf("done step into %+v\n", simultaneousPaths)
|
|
stepsNum += 1
|
|
}
|
|
|
|
return stepsNum
|
|
}
|
|
|
|
func isGhostWayDone(simulaneousPath []Node) bool {
|
|
containsNonZEnding := slices.ContainsFunc(simulaneousPath, func(curNode Node) bool {
|
|
name := curNode.Name
|
|
last := name[len(name) - 1]
|
|
return last != 'Z'
|
|
})
|
|
// log.Printf("checking if done for %+v : %t", simulaneousPath, !containsNonZEnding)
|
|
return !containsNonZEnding
|
|
}
|
|
|
|
func getNextNode(net Network, curNode Node, direction rune) Node {
|
|
var nextNodeName string
|
|
switch direction {
|
|
case 'L':
|
|
nextNodeName = curNode.Left
|
|
case 'R':
|
|
nextNodeName = curNode.Right
|
|
}
|
|
nextNode, found := net.Nodes[nextNodeName]
|
|
if !found {
|
|
panic(fmt.Sprintf("instruction %s from node %+v results in not found next node %s",
|
|
string(direction), curNode, nextNodeName))
|
|
}
|
|
return nextNode
|
|
}
|
|
|
|
func TraverseNetwork(net Network, path Path) int {
|
|
stepsNum := 0
|
|
|
|
curNode := net.Nodes["AAA"]
|
|
for curNode.Name != "ZZZ" {
|
|
direction := path.next()
|
|
var nextNodeName string
|
|
switch direction {
|
|
case 'L':
|
|
nextNodeName = curNode.Left
|
|
case 'R':
|
|
nextNodeName = curNode.Right
|
|
}
|
|
nextNode, found := net.Nodes[nextNodeName]
|
|
if !found {
|
|
panic(fmt.Sprintf("at step %d instruction %s from node %+v results in not found next node %s",
|
|
stepsNum, string(direction), curNode, nextNodeName))
|
|
}
|
|
curNode = nextNode
|
|
|
|
stepsNum += 1
|
|
}
|
|
|
|
return stepsNum
|
|
}
|
|
|
|
func Read(filename string) (Network, Path) {
|
|
net := Network{
|
|
Nodes: make(map[string]Node),
|
|
}
|
|
bytes, err := os.ReadFile(filename)
|
|
if err != nil {
|
|
panic(fmt.Sprintln("error reading file ", filename))
|
|
}
|
|
lines := strings.Split(string(bytes), "\n")
|
|
path := Path{
|
|
Instruction: strings.TrimSpace(lines[0]),
|
|
}
|
|
|
|
netDescriptions := lines[2:]
|
|
re := regexp.MustCompile(`(?P<NAME>\D{3}) = \((?P<LEFT>\D{3}), (?P<RIGHT>\D{3})\)`)
|
|
nameIndex := re.SubexpIndex("NAME")
|
|
leftIndex := re.SubexpIndex("LEFT")
|
|
rightIndex := re.SubexpIndex("RIGHT")
|
|
for _, line := range netDescriptions {
|
|
if line == "" {
|
|
continue
|
|
}
|
|
match := re.FindStringSubmatch(line)
|
|
if match == nil {
|
|
panic(fmt.Sprintln("error finding match in string : ", line))
|
|
}
|
|
node := Node{
|
|
Name: match[nameIndex],
|
|
Left: match[leftIndex],
|
|
Right: match[rightIndex],
|
|
}
|
|
net.Nodes[node.Name] = node
|
|
}
|
|
|
|
return net, path
|
|
}
|
|
|
|
type Node struct {
|
|
Name string
|
|
Left, Right string
|
|
}
|
|
|
|
type Network struct {
|
|
Nodes map[string]Node
|
|
}
|
|
|
|
type Path struct {
|
|
Instruction string
|
|
curStep int
|
|
}
|
|
|
|
func (p *Path) next() rune {
|
|
curInstruction := p.Instruction[p.curStep]
|
|
p.curStep += 1
|
|
if p.curStep == len(p.Instruction) {
|
|
p.curStep = 0
|
|
}
|
|
return rune(curInstruction)
|
|
}
|