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
This commit is contained in:
parent
76231d6a37
commit
5bd95a716f
@ -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
|
||||
|
||||
|
||||
55
day18/18a/main.go
Normal file
55
day18/18a/main.go
Normal file
@ -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
|
||||
// }
|
||||
100
day18/input
Normal file
100
day18/input
Normal file
@ -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]]]]
|
||||
10
day18/testInput
Normal file
10
day18/testInput
Normal file
@ -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]]]
|
||||
76
shared/BinaryTree.go
Normal file
76
shared/BinaryTree.go
Normal file
@ -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
|
||||
}
|
||||
@ -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
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user