code kata 230808

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)
+}

binary_tree_230804/stack.go

@@ -5,8 +5,8 @@ import "errors"
 type Stack []interface {
 }
 
-func NewStack() Stack {
+func NewStack() *Stack {
-	return Stack{}
+	return &Stack{}
 }
 
 func (s Stack) IsEmpty() bool {

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",
+	}
+}

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
+}

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)
+			}
+		})
+	}
+}

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)
+			}
 		})
 	}
 }

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)
+			}
+		})
+	}
+}