From 02e1a8ad1a5a7e8cb570b06a13348ba1eb54cdf3 Mon Sep 17 00:00:00 2001 From: VicRen Date: Tue, 8 Aug 2023 22:08:51 +0800 Subject: [PATCH] code kata 230808 --- binary_tree_230804/main_test.go | 30 ++++ binary_tree_230804/stack.go | 4 +- binary_tree_230807/main_test.go | 261 +++++++++++++++++++++++++++++ binary_tree_230807/stack.go | 36 ++++ int_to_string_230807/main_test.go | 43 +++++ reverse_string_230807/main_test.go | 12 ++ time_complexity/main_test.go | 87 ++++++++++ 7 files changed, 471 insertions(+), 2 deletions(-) create mode 100644 binary_tree_230807/main_test.go create mode 100644 binary_tree_230807/stack.go create mode 100644 int_to_string_230807/main_test.go create mode 100644 time_complexity/main_test.go diff --git a/binary_tree_230804/main_test.go b/binary_tree_230804/main_test.go index 9d1bc31..222c673 100644 --- a/binary_tree_230804/main_test.go +++ b/binary_tree_230804/main_test.go @@ -111,6 +111,31 @@ func postOrder2(n *node) { } } +func postOrder22(n *node) { + stack := NewStack() + p := n + var r *node = nil + for p != nil || !stack.IsEmpty() { + if p != nil { + stack.Push(p) + p = p.left + } else { + p = stack.Top().(*node) + if p.right != nil && p.right != r { + p = p.right + stack.Push(p) + p = p.left + } else { + x, _ := stack.Pop() + p = x.(*node) + visit(p) + r = p + p = nil + } + } + } +} + func visit(n *node) { fmt.Printf("Visiting Node: %s\n", n.value) } @@ -167,3 +192,8 @@ func TestPostOrder2(t *testing.T) { n := makeBinaryTree() postOrder2(n) } + +func TestPostOrder22(t *testing.T) { + n := makeBinaryTree() + postOrder22(n) +} diff --git a/binary_tree_230804/stack.go b/binary_tree_230804/stack.go index 31bf6f6..e39d540 100644 --- a/binary_tree_230804/stack.go +++ b/binary_tree_230804/stack.go @@ -5,8 +5,8 @@ import "errors" type Stack []interface { } -func NewStack() Stack { - return Stack{} +func NewStack() *Stack { + return &Stack{} } func (s Stack) IsEmpty() bool { diff --git a/binary_tree_230807/main_test.go b/binary_tree_230807/main_test.go new file mode 100644 index 0000000..a1f64a2 --- /dev/null +++ b/binary_tree_230807/main_test.go @@ -0,0 +1,261 @@ +package main + +import ( + "fmt" + "testing" +) + +type node struct { + left *node + right *node + value string +} + +func PreOrder(n *node) { + if n == nil { + return + } + visit(n) + PreOrder(n.left) + PreOrder(n.right) +} + +func PreOrder2(n *node) { + stack := MakeStack() + p := n + for p != nil || !stack.IsEmpty() { + if p != nil { + visit(p) + stack.Push(p) + p = p.left + } else { + p = stack.Pop().(*node) + p = p.right + } + } +} + +func PreOrder22(n *node) { + stack := MakeStack() + p := n + for p != nil || !stack.IsEmpty() { + if p != nil { + visit(p) + stack.Push(p) + p = p.left + } else { + p = stack.Pop().(*node) + p = p.right + } + } +} + +func InOrder(n *node) { + if n == nil { + return + } + InOrder(n.left) + visit(n) + InOrder(n.right) +} + +func InOrder2(n *node) { + stack := MakeStack() + p := n + for p != nil || !stack.IsEmpty() { + if p != nil { + stack.Push(p) + p = p.left + } else { + p = stack.Pop().(*node) + visit(p) + p = p.right + } + } +} + +func InOrder22(n *node) { + stack := MakeStack() + p := n + for p != nil || !stack.IsEmpty() { + if p != nil { + stack.Push(p) + p = p.left + } else { + p = stack.Pop().(*node) + visit(p) + p = p.right + } + } +} + +func PostOrder(n *node) { + if n == nil { + return + } + PostOrder(n.left) + PostOrder(n.right) + visit(n) +} + +func PostOrder2(n *node) { + stack := MakeStack() + p := n + var r *node = nil + for p != nil || !stack.IsEmpty() { + if p != nil { + stack.Push(p) + p = p.left + } else { + p = stack.Top().(*node) + if p.right != nil && p.right != r { + p = p.right + stack.Push(p) + p = p.left + } else { + p = stack.Pop().(*node) + visit(p) + r = p + p = nil + } + } + } +} + +func PostOrder22(n *node) { + stack := MakeStack() + p := n + var r *node = nil + for p != nil || !stack.IsEmpty() { + if p != nil { + stack.Push(p) + p = p.left + } else { + p = stack.Top().(*node) + if p.right != nil && p.right != r { + p = p.right + stack.Push(p) + p = p.left + } else { + p = stack.Pop().(*node) + visit(p) + r = p + p = nil + } + } + } +} + +func postOrder222(n *node) { + stack := MakeStack() + p := n + var r *node = nil + for p != nil || !stack.IsEmpty() { + if p != nil { + stack.Push(p) + p = p.left + } else { + p = stack.Top().(*node) + if p.right != nil && p.right != r { + p = p.right + stack.Push(p) + p = p.left + } else { + p = stack.Pop().(*node) + visit(p) + r = p + p = nil + } + } + } +} + +func postOrder2222(n *node) { + stack := MakeStack() + p := n + var r *node = nil + for p != nil || !stack.IsEmpty() { + if p != nil { + stack.Push(p) + p = p.left + } else { + p = stack.Top().(*node) + if p.right != nil && p.right != r { + p = p.right + stack.Push(p) + p = p.left + } else { + p = stack.Pop().(*node) + visit(p) + r = p + p = nil + } + } + } +} + +func TestPreOrder(t *testing.T) { + PreOrder(makeBinaryTree()) +} + +func TestPreOrder2(t *testing.T) { + PreOrder2(makeBinaryTree()) +} + +func TestPreOrder22(t *testing.T) { + PreOrder22(makeBinaryTree()) +} + +func TestInOrder(t *testing.T) { + InOrder(makeBinaryTree()) +} + +func TestInOrder2(t *testing.T) { + InOrder2(makeBinaryTree()) +} + +func TestInOrder22(t *testing.T) { + InOrder22(makeBinaryTree()) +} + +func TestPostOrder(t *testing.T) { + PostOrder(makeBinaryTree()) +} + +func TestPostOrder2(t *testing.T) { + PostOrder2(makeBinaryTree()) +} + +func TestPostOrder22(t *testing.T) { + PostOrder22(makeBinaryTree()) +} + +func TestPostOrder222(t *testing.T) { + postOrder222(makeBinaryTree()) +} + +func TestPostOrder2222(t *testing.T) { + postOrder2222(makeBinaryTree()) +} + +func visit(n *node) { + fmt.Printf("visiting node: %s\n", n.value) +} + +func makeBinaryTree() *node { + return &node{ + left: &node{ + left: &node{ + value: "D", + }, + value: "B", + }, + right: &node{ + right: &node{ + value: "E", + }, + value: "C", + }, + value: "A", + } +} diff --git a/binary_tree_230807/stack.go b/binary_tree_230807/stack.go new file mode 100644 index 0000000..ba93ef6 --- /dev/null +++ b/binary_tree_230807/stack.go @@ -0,0 +1,36 @@ +package main + +type Stack []interface { +} + +func MakeStack() *Stack { + return &Stack{} +} + +func (s Stack) IsEmpty() bool { + return len(s) == 0 +} + +func (s Stack) Len() int { + return len(s) +} + +func (s Stack) Top() interface{} { + if s.IsEmpty() { + return nil + } + return s[len(s)-1] +} + +func (s *Stack) Push(item interface{}) { + *s = append(*s, item) +} + +func (s *Stack) Pop() interface{} { + if s.IsEmpty() { + return nil + } + ret := (*s)[len(*s)-1] + *s = (*s)[:(len(*s) - 1)] + return ret +} diff --git a/int_to_string_230807/main_test.go b/int_to_string_230807/main_test.go new file mode 100644 index 0000000..38762d3 --- /dev/null +++ b/int_to_string_230807/main_test.go @@ -0,0 +1,43 @@ +package main + +import "testing" + +func IntToString(n int) string { + ret := make([]rune, 0) + for n > 0 { + num := n % 10 + ret = append(ret, '0'+rune(num)) + n /= 10 + } + return ReverseString(ret) +} + +func ReverseString(input []rune) string { + l := len(input) + for i := 0; i < l/2; i++ { + input[i], input[l-i-1] = input[l-i-1], input[i] + } + return string(input) +} + +func TestIntToString(t *testing.T) { + tt := []struct { + name string + input int + want string + }{ + {"1", 1, "1"}, + {"11", 11, "11"}, + {"112", 112, "112"}, + {"1123789", 1123789, "1123789"}, + } + + for _, tc := range tt { + t.Run(tc.name, func(t *testing.T) { + got := IntToString(tc.input) + if got != tc.want { + t.Errorf("IntToString(%d) = %s, want %s", tc.input, got, tc.want) + } + }) + } +} diff --git a/reverse_string_230807/main_test.go b/reverse_string_230807/main_test.go index db817b2..766e6b7 100644 --- a/reverse_string_230807/main_test.go +++ b/reverse_string_230807/main_test.go @@ -11,6 +11,14 @@ func ReverseString(s string) string { return string(tmp) } +func ReverseString2(s string) string { + tmp := []rune(s) + for f, t := 0, len(tmp)-1; t > f; f, t = f+1, t-1 { + tmp[f], tmp[t] = tmp[t], tmp[f] + } + return string(tmp) +} + func TestReverseString(t *testing.T) { tt := []struct { name string @@ -28,6 +36,10 @@ func TestReverseString(t *testing.T) { if got != tc.want { t.Errorf("ReverseString(%s) = %s, want %s", tc.input, got, tc.want) } + got = ReverseString2(tc.input) + if got != tc.want { + t.Errorf("ReverseString(%s) = %s, want %s", tc.input, got, tc.want) + } }) } } diff --git a/time_complexity/main_test.go b/time_complexity/main_test.go new file mode 100644 index 0000000..98ea9d9 --- /dev/null +++ b/time_complexity/main_test.go @@ -0,0 +1,87 @@ +package main + +import "testing" + +func binarySearch(arr []int, l, r, target int) int { + if l > r { + return -1 + } + mid := l + (r-l)/2 + if arr[mid] == target { + return mid + } else if arr[mid] > target { + return binarySearch(arr, l, mid-1, target) + } else { + return binarySearch(arr, mid+1, r, target) + } +} + +func TestBinarySearch(t *testing.T) { + type input struct { + arr []int + l int + r int + target int + } + tt := []struct { + name string + input input + want int + }{ + {"first", input{ + arr: []int{2, 3, 4, 5, 7}, + l: 0, + r: 4, + target: 5, + }, 3}, + {"second", input{ + arr: []int{2, 3, 4, 5, 7}, + l: 0, + r: 4, + target: 2, + }, 0}, + {"third", input{ + arr: []int{2, 3, 4, 5, 7}, + l: 0, + r: 4, + target: 7, + }, 4}, + } + + for _, tc := range tt { + t.Run(tc.name, func(t *testing.T) { + got := binarySearch(tc.input.arr, tc.input.l, tc.input.r, tc.input.target) + if got != tc.want { + t.Errorf("binarySearch(%v) = %d, want %d", tc.input, got, tc.want) + } + }) + } +} + +func sum(n int) int { + if n == 0 { + return 0 + } + return n + sum(n-1) +} + +func TestSum(t *testing.T) { + tt := []struct { + name string + input int + want int + }{ + {"1", 1, 1}, + {"2", 2, 3}, + {"3", 3, 6}, + {"4", 4, 10}, + } + for _, tc := range tt { + t.Run(tc.name, func(t *testing.T) { + got := sum(tc.input) + if got != tc.want { + t.Errorf("sum(%d)=%d, want %d", tc.input, got, tc.want) + } + }) + } +}