From 7c93bc48475f4c1301674784b421f8f5883081fb Mon Sep 17 00:00:00 2001 From: VicRen Date: Fri, 11 Aug 2023 19:52:25 +0800 Subject: [PATCH] code kata 230811 --- code_kata_230811/binary_tree_test.go | 109 +++++++++++++++++++++++++ code_kata_230811/int_to_string_test.go | 72 ++++++++++++++++ code_kata_230811/prime_factors_test.go | 46 +++++++++++ code_kata_230811/stack.go | 35 ++++++++ 4 files changed, 262 insertions(+) create mode 100644 code_kata_230811/binary_tree_test.go create mode 100644 code_kata_230811/int_to_string_test.go create mode 100644 code_kata_230811/prime_factors_test.go create mode 100644 code_kata_230811/stack.go diff --git a/code_kata_230811/binary_tree_test.go b/code_kata_230811/binary_tree_test.go new file mode 100644 index 0000000..a64754c --- /dev/null +++ b/code_kata_230811/binary_tree_test.go @@ -0,0 +1,109 @@ +package main + +import ( + "fmt" + "testing" +) + +func preOrder(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) { + 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) { + 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 TestInOrder(t *testing.T) { + inOrder(makeBinaryTree()) +} + +func TestPostOrder(t *testing.T) { + postOrder(makeBinaryTree()) +} + +func visit(n *node) { + if n == nil { + return + } + fmt.Printf("visiting node %s\n", n.value) +} + +type node struct { + left *node + right *node + value string +} + +func makeBinaryTree() *node { + return &node{ + left: &node{ + left: &node{ + value: "D", + }, + right: &node{ + value: "E", + }, + value: "B", + }, + right: &node{ + left: &node{ + value: "F", + }, + right: &node{ + value: "G", + }, + value: "C", + }, + value: "A", + } +} diff --git a/code_kata_230811/int_to_string_test.go b/code_kata_230811/int_to_string_test.go new file mode 100644 index 0000000..895f782 --- /dev/null +++ b/code_kata_230811/int_to_string_test.go @@ -0,0 +1,72 @@ +package main + +import "testing" + +func IntToString(n int) string { + var ret []byte + for n > 0 { + ret = append(ret, '0'+byte(n%10)) + n /= 10 + } + return ReverseString(string(ret)) +} + +func IntToString2(n int) string { + var ret []byte + for n > 0 { + ret = append([]byte{'0' + byte(n%10)}, ret...) + n /= 10 + } + return string(ret) +} + +func ReverseString(s string) string { + ret := []rune(s) + for l, r := 0, len(ret)-1; l < r; l, r = l+1, r-1 { + ret[l], ret[r] = ret[r], ret[l] + } + return string(ret) +} + +func TestReverseString(t *testing.T) { + tt := []struct { + name string + input string + want string + }{ + {"test", "test", "tset"}, + {"testing", "testing", "gnitset"}, + {"i am testing", "i am testing", "gnitset ma i"}, + } + + for _, tc := range tt { + t.Run(tc.name, func(t *testing.T) { + got := ReverseString(tc.input) + if got != tc.want { + t.Errorf("ReverseString(%s) = %s, want %s\n", tc.input, got, tc.want) + } + }) + } +} + +func TestIntToString(t *testing.T) { + tt := []struct { + name string + input int + want string + }{ + {"1", 1, "1"}, + {"12", 12, "12"}, + {"123", 123, "123"}, + } + + for _, tc := range tt { + t.Run(tc.name, func(t *testing.T) { + //got := IntToString(tc.input) + got := IntToString2(tc.input) + if got != tc.want { + t.Errorf("IntToString(%d) = %s, want %s\n", tc.input, got, tc.want) + } + }) + } +} diff --git a/code_kata_230811/prime_factors_test.go b/code_kata_230811/prime_factors_test.go new file mode 100644 index 0000000..b1d79de --- /dev/null +++ b/code_kata_230811/prime_factors_test.go @@ -0,0 +1,46 @@ +package main + +import ( + "reflect" + "testing" +) + +func PrimeFactorsOf(n int) []int { + ret := make([]int, 0) + d := 2 + for d < n { + for n%d == 0 { + ret = append(ret, d) + n /= d + } + d++ + } + if n > 1 { + ret = append(ret, n) + } + return ret +} + +func TestPrimeFactorsOf(t *testing.T) { + tt := []struct { + name string + input int + want []int + }{ + {"1", 1, []int{}}, + {"2", 2, []int{2}}, + {"4", 4, []int{2, 2}}, + {"8", 8, []int{2, 2, 2}}, + {"9", 9, []int{3, 3}}, + {"a very large number", 2 * 17 * 37 * 71 * 73, []int{2, 17, 37, 71, 73}}, + } + + for _, tc := range tt { + t.Run(tc.name, func(t *testing.T) { + got := PrimeFactorsOf(tc.input) + if !reflect.DeepEqual(got, tc.want) { + t.Errorf("PrimeFactorsOf(%d) = %v, want %v\n", tc.input, got, tc.want) + } + }) + } +} diff --git a/code_kata_230811/stack.go b/code_kata_230811/stack.go new file mode 100644 index 0000000..16fc9d5 --- /dev/null +++ b/code_kata_230811/stack.go @@ -0,0 +1,35 @@ +package main + +type Stack []interface{} + +func MakeStack() *Stack { + return &Stack{} +} + +func (s Stack) Len() int { + return len(s) +} + +func (s Stack) IsEmpty() bool { + return len(s) == 0 +} + +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)[(*s).Len()-1] + *s = (*s)[:len(*s)-1] + return ret +}