day 18a incomplete

was unable to complete the challenge today

Ideally, I would like to wait for generics to release in Go version 1.18 (February 2022)

decided to spend the time working on an implementation of a Binary Search Tree that makes use of the string that is currently stored in the Node Item

day14/14a/main.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"AdventOfCode2021/shared"
 	"bufio"
 	"fmt"
 	"math"
@@ -24,10 +25,10 @@ func main() {
 	}
 
 	//Fill initial list
-	list := LinkedList{Head: &Node{Value: string(startingString[0]), Next: nil}}
+	list := shared.LinkedList{Head: &shared.Node{Value: string(startingString[0]), Next: nil}}
 	current := list.Head
 	for i := 1; i < len(startingString); i++ {
-		node := &Node{Value: string(startingString[i]), Next: nil}
+		node := &shared.Node{Value: string(startingString[i]), Next: nil}
 		count[string(startingString[i])]++
 		current.Next = node
 		current = node
@@ -62,29 +63,6 @@ func main() {
 
 }
 
-type LinkedList struct {
-	Head *Node
-}
-
-func (l *LinkedList) InsertItem(first *Node, second *Node, value string) {
-	first.Next = &Node{Value: value, Next: second}
-}
-
-func (l *LinkedList) PrintList() {
-	list := []string{}
-	current := l.Head
-	for current != nil {
-		list = append(list, current.Value)
-		current = current.Next
-	}
-	fmt.Println(list)
-}
-
-type Node struct {
-	Value string
-	Next  *Node
-}
-
 func returnContent(path string) *[]string {
 	//read file and return it as an array of integers
 

day18/18a/main.go

@@ -0,0 +1,55 @@
+package main
+
+import (
+	"AdventOfCode2021/shared"
+)
+
+func main() {
+	//content := returnContent("../input")
+	//content := returnContent("../testInput")
+
+	list := []int{5, 1, 3, 5, 4, 6, 2, 7, 9, 8, 0}
+
+	tree := shared.BinaryTree{}
+
+	for _, v := range list {
+		tree.Insert(v)
+	}
+
+	tree.InOrder(tree.Head)
+
+	//Had no Idea where to even start with this challenge
+
+	//Ideally wanted to use a binary tree
+	//will be looking to make use of generics when they release in Go verison 1.18
+
+}
+
+// func returnContent(path string) *[]int {
+// 	//read file and return it as an array of integers
+
+// 	file, err := os.Open(path)
+// 	var content []int
+
+// 	if err != nil {
+// 		fmt.Println("Unlucky, the file didn't open")
+// 		return &content
+// 	}
+// 	defer file.Close()
+
+// 	scanner := bufio.NewScanner(file)
+// 	regex, _ := regexp.Compile(`[-+]?[\d]+`)
+
+// 	strings := []string{}
+
+// 	for scanner.Scan() {
+// 		strings = regex.FindAllString(scanner.Text(), 4)
+// 	}
+
+// 	for _, val := range strings {
+// 		num, _ := strconv.Atoi(val)
+// 		content = append(content, num)
+// 	}
+
+// 	return &content
+// }

day18/input

@@ -0,0 +1,100 @@
+[[[[7,7],2],[[9,2],4]],[[[9,1],5],[[9,6],[6,4]]]]
+[[[2,0],[8,[9,4]]],[[1,0],0]]
+[8,[[[9,5],7],[9,7]]]
+[[[[1,3],[1,8]],[[8,8],5]],[[7,[4,0]],2]]
+[[[[7,8],3],[9,3]],5]
+[[5,[[9,3],4]],[[[0,1],7],[6,[8,3]]]]
+[[[[1,6],[4,1]],[0,3]],[9,[[4,3],[3,2]]]]
+[[[[7,9],8],4],[[[9,0],1],[[9,8],[0,5]]]]
+[[[8,7],[6,1]],[[[1,3],[6,6]],[5,[4,5]]]]
+[[[[9,8],[2,1]],[[2,3],2]],5]
+[6,3]
+[[[9,1],6],[[[7,1],[6,8]],[[8,3],[6,4]]]]
+[4,[[8,[7,1]],[8,[7,2]]]]
+[[[1,6],[9,[0,8]]],[[6,7],[2,[4,5]]]]
+[[[[1,8],[9,2]],5],[[[8,6],[2,1]],[0,6]]]
+[[[[0,2],4],[4,[3,6]]],7]
+[[[[7,5],5],7],[[[6,0],4],[5,0]]]
+[[2,1],[[[3,0],[1,4]],7]]
+[[[[9,4],[2,8]],9],[[[9,1],[7,3]],[1,[2,1]]]]
+[[[[4,2],3],[6,4]],[[6,0],[1,5]]]
+[2,6]
+[[4,6],[[2,2],[3,0]]]
+[[[[6,4],[0,7]],[0,8]],[[[6,7],2],7]]
+[[8,[[4,0],[8,4]]],1]
+[[3,[6,6]],[[[6,4],[1,5]],[4,0]]]
+[[[9,5],[5,[4,0]]],[[1,[0,6]],[[5,8],0]]]
+[[[[6,1],8],[3,7]],[[[6,4],0],[[4,8],4]]]
+[[[[3,1],3],[[3,6],[3,8]]],[[[6,7],0],2]]
+[[4,1],[[[4,8],7],[3,0]]]
+[[[[0,6],[1,3]],[[0,8],[1,9]]],3]
+[[0,[3,1]],[[[0,0],6],[[7,6],3]]]
+[[6,[[5,4],7]],[8,[5,5]]]
+[[[6,3],[[8,9],6]],2]
+[9,[[8,3],7]]
+[[[1,[3,0]],[[3,7],5]],[[5,8],[[3,7],[8,6]]]]
+[[[[6,1],2],[[7,8],[3,9]]],[[[3,6],[6,8]],[5,5]]]
+[[[[6,8],[7,1]],[8,1]],[[[1,6],9],[[3,3],[7,9]]]]
+[[[[6,9],0],[5,6]],3]
+[[[9,6],[[0,5],[2,0]]],[[[6,7],7],[2,6]]]
+[[0,[5,8]],[[1,[4,6]],[4,6]]]
+[[[[3,3],4],[0,1]],[[[6,5],0],[2,3]]]
+[0,4]
+[[5,5],[[[6,5],8],7]]
+[[[[7,3],[9,1]],[[9,0],2]],[[7,[8,3]],[[9,5],[7,3]]]]
+[[[[1,2],[7,7]],[9,0]],[0,7]]
+[[[0,[8,6]],[1,3]],[[6,6],9]]
+[[[0,2],[4,7]],0]
+[[[9,[9,6]],1],[[[1,5],[1,7]],[[5,1],[8,1]]]]
+[[[6,9],4],0]
+[[[[4,9],6],5],[7,[3,[9,8]]]]
+[[6,[6,[5,7]]],[0,[[7,4],8]]]
+[[4,[5,0]],[2,3]]
+[[[[8,6],9],[3,[1,2]]],[1,[8,[3,8]]]]
+[[[8,4],[7,2]],9]
+[[[[6,3],[6,2]],[2,[0,0]]],[[[6,4],[1,6]],[[3,5],6]]]
+[7,[[[2,4],0],[9,[9,9]]]]
+[[[9,2],8],[[2,[9,9]],[9,[7,4]]]]
+[1,[[0,7],[[1,6],0]]]
+[[[[5,5],4],8],[[9,[6,5]],[[7,4],7]]]
+[[[[7,6],4],[8,4]],[2,[1,[5,1]]]]
+[[[2,[1,2]],7],[7,[[9,9],3]]]
+[1,[[3,[9,9]],[5,6]]]
+[[3,[[1,8],4]],[[9,[6,9]],2]]
+[[[2,[4,5]],[1,[9,0]]],[4,1]]
+[[[7,[5,9]],[7,7]],[[3,[4,0]],[2,[0,0]]]]
+[[[0,[9,8]],0],[8,[7,1]]]
+[[[6,6],[0,[4,8]]],3]
+[[1,[[8,2],[9,9]]],3]
+[[2,[5,[6,7]]],[[5,3],3]]
+[[2,[[5,0],[8,5]]],[[7,[0,5]],[[5,7],3]]]
+[[[[9,4],[4,0]],[6,[7,8]]],[[7,6],1]]
+[[0,2],6]
+[[[7,5],[[7,4],[4,1]]],[3,[[6,6],[5,5]]]]
+[[3,[[0,7],8]],[[1,7],[5,0]]]
+[[9,[[9,7],[3,0]]],6]
+[[[[7,9],2],[3,[5,4]]],[[[9,4],[5,8]],[[5,0],[4,2]]]]
+[[[[4,3],6],7],[[2,6],[5,[0,1]]]]
+[[1,[3,5]],[[4,[5,0]],1]]
+[[[9,[3,9]],8],[9,[[2,9],[2,2]]]]
+[[[0,[5,0]],[[4,4],3]],6]
+[[[9,3],[[2,4],[8,4]]],[[[6,8],[3,6]],[[4,6],[1,2]]]]
+[[[[8,2],[3,2]],[4,[1,1]]],[[[7,2],1],[[9,9],[0,5]]]]
+[[[6,3],[[3,6],9]],[6,5]]
+[8,[[[8,7],3],[4,3]]]
+[[[[8,3],3],[[6,1],9]],[[[2,4],[5,9]],[[9,7],1]]]
+[[[2,[6,4]],[[0,1],3]],[[[1,2],9],[4,7]]]
+[7,9]
+[[[3,[1,4]],5],[[4,[5,1]],8]]
+[[[[7,6],4],0],[5,5]]
+[[4,[[5,2],5]],[[[0,4],[6,1]],[[3,0],[4,9]]]]
+[[[[8,6],[6,1]],9],[[[4,1],2],[[9,2],3]]]
+[[[6,1],[[8,9],[9,0]]],[[[4,4],[3,0]],[[4,2],[9,9]]]]
+[1,[[[8,8],3],7]]
+[[1,[4,[6,8]]],[1,[7,0]]]
+[6,[[3,[2,4]],[[4,5],[5,3]]]]
+[8,[[9,[6,0]],[[2,5],0]]]
+[[5,[0,8]],[[7,1],[[5,9],2]]]
+[[[5,8],[[1,1],4]],[[0,1],[4,3]]]
+[[3,[1,[7,3]]],[[[6,4],9],[[2,8],[0,1]]]]
+[[[6,[2,5]],5],[0,[[5,3],[4,2]]]]

day18/testInput

@@ -0,0 +1,10 @@
+[[[0,[5,8]],[[1,7],[9,6]]],[[4,[1,2]],[[1,4],2]]]
+[[[5,[2,8]],4],[5,[[9,9],0]]]
+[6,[[[6,2],[5,6]],[[7,6],[4,7]]]]
+[[[6,[0,7]],[0,9]],[4,[9,[9,0]]]]
+[[[7,[6,4]],[3,[1,3]]],[[[5,5],1],9]]
+[[6,[[7,3],[3,2]]],[[[3,8],[5,7]],4]]
+[[[[5,4],[7,7]],8],[[8,3],8]]
+[[9,3],[[9,9],[6,[4,9]]]]
+[[2,[[7,7],7]],[[5,8],[[9,3],[0,2]]]]
+[[[[5,2],5],[8,[3,7]]],[[5,[7,5]],[4,4]]]

shared/BinaryTree.go

@@ -0,0 +1,76 @@
+package shared
+
+import (
+	"fmt"
+	"strconv"
+)
+
+type BinaryTree struct {
+	Head *Node
+}
+
+func (t *BinaryTree) Insert(val int) {
+	if t.Head == nil {
+		t.Head = &Node{Value: strconv.Itoa(val), Left: nil, Right: nil}
+		return
+	}
+
+	current := t.Head
+	var parent *Node = nil
+
+	for {
+		currentVal, _ := strconv.Atoi(current.Value)
+		parent = current
+		left := true
+		if val > currentVal {
+			left = false
+			_, current = t.Traverse(current)
+		} else {
+			current, _ = t.Traverse(current)
+		}
+
+		if current == nil {
+			current = &Node{Value: strconv.Itoa(val), Left: nil, Right: nil, Parent: parent}
+			if left {
+				parent.Left = current
+			} else {
+				parent.Right = current
+			}
+			return
+		}
+	}
+}
+
+func (t *BinaryTree) InOrder(start *Node) {
+	if start.Left != nil {
+		t.InOrder(start.Left)
+	}
+	fmt.Print(start.Value, " ")
+	if start.Right != nil {
+		t.InOrder(start.Right)
+	}
+}
+
+func (t *BinaryTree) PreOrder(start *Node) {
+	fmt.Print(start.Value, " ")
+	if start.Left != nil {
+		t.PreOrder(start.Left)
+	}
+	if start.Right != nil {
+		t.PreOrder(start.Right)
+	}
+}
+
+func (t *BinaryTree) PostOrder(start *Node) {
+	if start.Left != nil {
+		t.PostOrder(start.Left)
+	}
+	if start.Right != nil {
+		t.PostOrder(start.Right)
+	}
+	fmt.Print(start.Value, " ")
+}
+
+func (t *BinaryTree) Traverse(current *Node) (left *Node, right *Node) {
+	return current.Left, current.Right
+}

shared/Node.go

@@ -1,6 +1,18 @@
 package shared
 
+//Waiting for generic types to release,
+//this will allow for a Node with a different value type
+
 type Node struct {
 	Value string
+
+	//Universal
+	Parent *Node
+
+	//For LLs, Stacks, Queues...
 	Next *Node
+
+	//For Binary Trees...
+	Left  *Node
+	Right *Node
 }