From a17153662e830609d98d926690a9a0060f1e1c43 Mon Sep 17 00:00:00 2001
From: Davide Oddone <davide@oddone.dev>
Date: Sat, 9 Dec 2023 23:00:54 +0100
Subject: [PATCH] Working d8p1

---
 .gitignore        |   1 +
 day08/charpath.go | 124 +++++++++++++++++++++++++++++++---------------
 2 files changed, 85 insertions(+), 40 deletions(-)

diff --git a/.gitignore b/.gitignore
index f50f047..6b4b990 100644
--- a/.gitignore
+++ b/.gitignore
@@ -22,3 +22,4 @@ go.work
 
 # Problem data
 input*.txt
+inputs/
diff --git a/day08/charpath.go b/day08/charpath.go
index c30a8c2..ca4b812 100644
--- a/day08/charpath.go
+++ b/day08/charpath.go
@@ -1,23 +1,23 @@
 package main
 
-import(
-	"fmt"
+import (
 	"bufio"
+	"fmt"
 	"os"
-	"sync"
 	"regexp"
-	"context"
+	"sync"
 )
 
 const LEFT = 'L'
 
 type Nodes struct {
-    mu 			sync.Mutex
-    commands 	[]int32
-    singleN		[]int32
-    leftN		[]int32
-    rightN		[]int32
-    steps		uint64
+	mu       sync.Mutex
+	commands []int32
+	singleN  []int32
+	leftN    []int32
+	rightN   []int32
+	index    int
+	steps    uint64
 }
 
 func check(e error) {
@@ -32,64 +32,108 @@ func PrintAndWait(x ...any) {
 }
 
 func (n *Nodes) toByteSingle(s string) {
-    // I've just received something like AAA
-    var temp int32
-    for i := 0; i < len(s); i++ {
-        a := int32(s[i])
-        temp +=  a << (i*8) 
-    }
+	// I've just received something like AAA
+	var temp int32
+	for i := len(s) - 1; i >= 0; i-- {
+		a := int32(s[i])
+		temp += a << ((len(s) - 1 - i) * 8)
+	}
 	n.singleN = append(n.singleN, temp)
 }
 
 func (n *Nodes) toByteDuet(s, r string) {
-    // I've just received something like AAA BBB
-    var tempL, tempR int32
-    for i := 0; i < len(s); i++ {
-        tempL += int32(s[i]) << (i*8)
-        tempR += int32(s[i]) << (i*8)
-    }
-    n.leftN = append(n.leftN, tempL)
-    n.rightN = append(n.rightN, tempR) 
+	// I've just received something like AAA BBB
+	var tempL, tempR int32
+	for i := len(s) - 1; i >= 0; i-- { 
+		tempL += int32(s[i]) << ((len(s) - 1 - i) * 8)
+		tempR += int32(r[i]) << ((len(s) - 1 - i) * 8)
+		//fmt.Printf("Received %c (%b), now I have %b | ", s[i], s[i], tempL)
+		//fmt.Printf("Received %c (%b), now I have %b\n", r[i], r[i], tempR)
+		//fmt.Scanln() 
+	}
+	n.leftN = append(n.leftN, tempL)
+	n.rightN = append(n.rightN, tempR)
 }
 
-func (n *Nodes) findNext(direction int32, index int, ctx context.Context) {
-    
+func (n *Nodes) findNext(myN int32) {
+	//var wg sync.WaitGroup
+	for i := 0; i < len(n.singleN); i++ {
+    	if myN^n.singleN[i] == 0 {
+        	n.index = i
+        	break
+    	}
+	}
 }
 
 func main() {
-	file, err := os.Open("./inputs/day08_test_input")
+	file, err := os.Open("./inputs/day08_input")
 	check(err)
 	defer file.Close()
 	// Struct with my node
 	n := Nodes{}
 	// Prepare the regex
 	repath := regexp.MustCompile("([A-Z]{3})")
-	
+	// Build the END
+	var END = 'Z'
+	END += ('Z' << 8)
+	END += ('Z' << 16)
+
 	scanner := bufio.NewScanner(file)
 	scanner.Scan()
 	// First line, RL commands
 	strCommands := scanner.Text()
 	// Get every char inside the string just obtained
 	for i := 0; i < len(strCommands); i++ {
-    	n.commands = append(n.commands, int32(strCommands[i])) 
+		n.commands = append(n.commands, int32(strCommands[i]))
 	}
 	// One empty line
 	scanner.Scan()
 	// X = (Y, Z)
 	// We regex this one
 	for scanner.Scan() {
-    	tempNodes := repath.FindAllString(scanner.Text(), -1)
-    	n.toByteSingle(tempNodes[0])
-    	n.toByteDuet(tempNodes[1], tempNodes[2]) 
+		tempNodes := repath.FindAllString(scanner.Text(), -1)
+		n.toByteSingle(tempNodes[0])
+		n.toByteDuet(tempNodes[1], tempNodes[2])
 	}
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
 	// We start from 0, we find the match
-	for i, j := 0, 0; ; i++ {
-    	// We do a circular loop
-    	i =  i % len(n.commands)
-    	// A function that has the context as an argument
-    	n.findNext(int32(i), j, ctx)  
-    	j++
+	// Let's start an infinite loop
+	// Circular index
+	i := 0
+	// We start from the AAA element
+	START := 'A'
+	START += ('A' << 8)
+	START += ('A' << 16)
+	matching := START
+	// Store where AAA is
+	n.findNext(matching) 
+	// By default, we will assume we are on the right
+	// If we are not, we are in the left
+	matching = n.rightN[n.index] 
+	if n.commands[i]^LEFT == 0 {
+		matching = n.leftN[n.index]
 	}
+	n.steps++
+	// Infinite loop
+	for {
+		// Every step is in a single direction. For every step, we may need to
+		// scan len(n.singleN) elements.
+		// Circular loop
+		n.findNext(matching)
+		// Increment i after finding the match
+		i++
+		i = i % len(n.commands)
+		// By default, we will assume we are on the right
+		matching = n.rightN[n.index]
+		//PrintAndWait()
+		// If we are not, we are in the left
+		if n.commands[i]^LEFT == 0 {
+			matching = n.leftN[n.index]
+		}
+		n.steps++
+		// If we find ZZZ, end
+		if matching^END == 0 {
+			break
+		}
+	}
+	fmt.Printf("\nSteps: %d\n", n.steps)
 }