update

easy/520.detect-capital.go

@@ -0,0 +1,15 @@
+func detectCapitalUse(word string) bool {
+	n := len(word)
+	if n <= 1 {
+		return true
+	}
+	up, lo := 0, 0
+	for _, r := range word {
+		if 'a' <= r && r <= 'z' {
+			lo++
+		} else if 'A' <= r && r <= 'Z' {
+			up++
+		}
+	}
+	return (up == 1 && 'A' <= word[0] && word[0] <= 'Z') || up == 0 || lo == 0
+}

easy/521.longest-uncommon-subsequence-i.go

@@ -0,0 +1,16 @@
+func findLUSlength(a string, b string) (cnt int) {
+	m, n := len(a), len(b)
+	if m != n {
+		if m < n {
+			return n
+		}
+		return m
+	} else {
+		for i := range a {
+			if a[i] != b[i] {
+				return m
+			}
+		}
+		return -1
+	}
+}

easy/530.minimum-absolute-difference-in-bst.go

@@ -0,0 +1,41 @@
+var pre int = 0
+var ini bool = false
+
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func getMinimumDifference(root *TreeNode) (diff int) {
+	pre, diff = 0, 1<<32-1
+	ini = false
+	inorder(root, &diff)
+	return
+}
+
+func inorder(root *TreeNode, diff *int) {
+	if root == nil {
+		return
+	}
+	inorder(root.Left, diff)
+	if ini {
+		d := abs(root.Val - pre)
+		if d < *diff {
+			*diff = d
+		}
+	} else {
+		ini = true
+	}
+	pre = root.Val
+	inorder(root.Right, diff)
+}
+
+func abs(x int) int {
+	if x < 0 {
+		return -x
+	}
+	return x
+}

easy/532.k-diff-pairs-in-an-array.go

@@ -0,0 +1,31 @@
+type pair struct {
+	_1 int
+	_2 int
+}
+
+func findPairs(nums []int, k int) (cnt int) {
+	n := len(nums)
+	if n < 2 {
+		return
+	}
+	sort.Ints(nums)
+	m := make(map[pair]bool)
+	fast, slow := 1, 0
+	for fast < n {
+		if det := nums[fast] - nums[slow]; det == k {
+			if _, ok := m[pair{nums[slow], nums[fast]}]; !ok {
+				cnt++
+				m[pair{nums[slow], nums[fast]}] = true
+			}
+			fast, slow = fast+1, slow+1
+		} else if det < k {
+			fast++
+		} else {
+			slow++
+			if fast == slow {
+				fast++
+			}
+		}
+	}
+	return
+}

easy/538.convert-bst-to-greater-tree.go

@@ -0,0 +1,25 @@
+var sum int = 0
+
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func convertBST(root *TreeNode) *TreeNode {
+	sum = 0
+	inorder(root)
+	return root
+}
+
+func inorder(root *TreeNode) {
+	if root == nil {
+		return
+	}
+	inorder(root.Right)
+	root.Val += sum
+	sum = root.Val
+	inorder(root.Left)
+}

easy/541.reverse-string-ii.go

@@ -0,0 +1,19 @@
+func reverseStr(s string, k int) string {
+	runes := []rune(s)
+	n := len(s)
+	beg, end := 0, k-1
+	for beg < n {
+		reverse(runes, n, beg, end)
+		beg, end = beg+2*k, end+2*k
+	}
+	return string(runes)
+}
+
+func reverse(runes []rune, n int, l int, r int) {
+	if n <= r {
+		r = n - 1
+	}
+	for ; l < r; l, r = l+1, r-1 {
+		runes[l], runes[r] = runes[r], runes[l]
+	}
+}

easy/543.diameter-of-binary-tree.go

@@ -0,0 +1,30 @@
+var max int = 0
+
+/**
+ * Definition for a binary tree node.
+ * type TreeNode struct {
+ *     Val int
+ *     Left *TreeNode
+ *     Right *TreeNode
+ * }
+ */
+func diameterOfBinaryTree(root *TreeNode) int {
+	max = 0
+	postorder(root, &max)
+	return
+}
+
+func postorder(root *TreeNode, max *int) int {
+	if root == nil {
+		return -1
+	}
+	l := postorder(root.Left, max) + 1
+	r := postorder(root.Right, max) + 1
+	if *max < l+r {
+		*max = l + r
+	}
+	if l < r {
+		return r
+	}
+	return l
+}