update

medium/117.js

@@ -42,21 +42,21 @@ var connect = function (root) {
 
 function __main__() {
     /*eslint no-console: ["error", { allow: ["log"] }] */
-    let logger = console.log.bind(console)
+    const logger = console.log.bind(console)
     //       1
     //      / \
     //     2   3
     //    /    /\
     //   4    6  7
-    let n7 = new TreeLinkNode(7)
-    let n6 = new TreeLinkNode(6)
-    let n4 = new TreeLinkNode(4)
-    let n3 = new TreeLinkNode(3)
+    const n7 = new TreeLinkNode(7)
+    const n6 = new TreeLinkNode(6)
+    const n4 = new TreeLinkNode(4)
+    const n3 = new TreeLinkNode(3)
     n3.left = n6
     n3.right = n7
-    let n2 = new TreeLinkNode(2)
+    const n2 = new TreeLinkNode(2)
     n2.left = n4
-    let n1 = new TreeLinkNode(1)
+    const n1 = new TreeLinkNode(1)
     n1.left = n2
     n1.right = n3
     connect(n1)

medium/148.go

@@ -8,11 +8,21 @@ package main
  * }
  */
 func sortList(head *ListNode) *ListNode {
-	return nil
-}
-
-func mergeSort() {
-
+	if head == nil || head.Next == nil {
+		return head
+	}
+	// !!Must split []int{1, 2} into 1 & 2
+	slow, fast := head, head.Next // So, fast = head.Next
+	for fast != nil && fast.Next != nil {
+		slow = slow.Next
+		fast = fast.Next.Next
+	}
+	left := head
+	right := slow.Next
+	slow.Next = nil // Unlink in the middle
+	left = sortList(left)
+	right = sortList(right)
+	return mergeList(left, right)
 }
 
 func mergeList(l1, l2 *ListNode) *ListNode {
@@ -36,8 +46,8 @@ func mergeList(l1, l2 *ListNode) *ListNode {
 	return dummy.Next
 }
 
-func main() {
-	l1 := toLinkedList([]int{
-		3, 52, 6, 8, 4})
-	printList(sortList(l1))
-}
+// func main() {
+// 	l1 := toLinkedList([]int{
+// 		2, 7, 4, 2, 8, 54, 3, 2})
+// 	printList(sortList(l1))
+// }

medium/150.go

@@ -0,0 +1,46 @@
+package main
+
+import (
+	"strconv"
+)
+
+func evalRPN(tokens []string) int {
+	length := len(tokens)
+	if length == 0 {
+		return 0
+	}
+	vals := make([]int, 0)
+	for i := 0; i < length; i++ {
+		switch tokens[i] {
+		case "+":
+			size := len(vals)
+			a, b := vals[size-2], vals[size-1]
+			vals = vals[:size-2]
+			vals = append(vals, a+b)
+		case "-":
+			size := len(vals)
+			a, b := vals[size-2], vals[size-1]
+			vals = vals[:size-2]
+			vals = append(vals, a-b)
+		case "*":
+			size := len(vals)
+			a, b := vals[size-2], vals[size-1]
+			vals = vals[:size-2]
+			vals = append(vals, a*b)
+		case "/":
+			size := len(vals)
+			a, b := vals[size-2], vals[size-1]
+			vals = vals[:size-2]
+			vals = append(vals, a/b)
+		default:
+			val, _ := strconv.Atoi(tokens[i])
+			vals = append(vals, val)
+		}
+	}
+	return vals[0]
+}
+
+// func main() {
+// 	println(evalRPN([]string{ // The answer: 22
+// 		"10", "6", "9", "3", "+", "-11", "*", "/", "*", "17", "+", "5", "+"}))
+// }

medium/151.js

@@ -0,0 +1,17 @@
+'use strict'
+
+/**
+ * @param {string} str
+ * @returns {string}
+ */
+var reverseWords = function(str) { // No builtin next time :)
+    return str.trim().split(/\s+/).reverse().join(' ')
+}
+
+function __main__() {
+    /* eslint no-console: ["error", {"allow": ["log"]}] */
+    const logger = console.log.bind(console)
+    logger(reverseWords('    test  reverse words '))
+}
+
+__main__()

medium/152.go

@@ -0,0 +1,25 @@
+package main
+
+func maxProduct(nums []int) int {
+	length := len(nums)
+	if length == 0 {
+		return 0
+	}
+	globalMax := nums[0]
+	min, max := nums[0], nums[0]
+	for i := 1; i < length; i++ {
+		// Negtive num makes bigger num smaller & smaller num bigger
+		if nums[i] < 0 {
+			min, max = max, min
+		}
+		min = minInt(nums[i], nums[i]*min)
+		max = maxInt(nums[i], nums[i]*max)
+		globalMax = maxInt(max, globalMax)
+	}
+	return globalMax
+}
+
+// func main() {
+// 	println(maxProduct([]int{ // The answer: 144
+// 		2, -1, 6, 2, 1, -6, 0, 8, 7}))
+// }

medium/153.go

@@ -0,0 +1,30 @@
+package main
+
+func findMin(nums []int) int {
+	length := len(nums)
+	if length == 1 {
+		return nums[0]
+	}
+	beg, end := 0, length-1
+	for beg < end {
+		if nums[beg] < nums[end] {
+			return nums[beg] // No pivot
+		}
+		mid := (beg + end) / 2
+		if nums[mid] > nums[beg] { // Pivot at right
+			beg = mid
+		} else { // ...At left
+			end = mid
+		}
+	}
+	return nums[beg+1]
+}
+
+// func main() {
+// 	println(findMin([]int{
+// 		4, 5, 6, 7, 0, 1, 2}))
+// 	println(findMin([]int{
+// 		0, 1, 2}))
+// 	println(findMin([]int{
+// 		2, 3, 1}))
+// }

medium/162.go

@@ -0,0 +1,50 @@
+package main
+
+func findPeakElement(nums []int) int { // Return peak index
+	length := len(nums)
+	if length == 1 {
+		return 0
+	}
+	beg, end := 0, length-1 // Index is important
+	mid := (beg + end) / 2
+	for beg < end {
+		midLeft := (beg + mid) / 2
+		if nums[midLeft] > nums[mid] {
+			end = mid
+			mid = midLeft
+			continue
+		}
+		midRight := (mid + end) / 2
+		if nums[midRight] > nums[mid] {
+			beg = mid
+			mid = midRight
+			continue
+		}
+		if mid == midRight {
+			break // Avoid infinity loop
+		}
+		beg = midLeft
+		end = midRight
+	}
+	if end > length-1 || nums[mid] > nums[end] {
+		return mid
+	}
+	return end
+}
+
+// func main() {
+// 	println(findPeakElement([]int{
+// 		1, 2, 1, 3, 5, 6, 4}))
+// 	println(findPeakElement([]int{
+// 		1, 2}))
+// 	println(findPeakElement([]int{
+// 		1, 2, 1, 3, 2, 1}))
+// 	println(findPeakElement([]int{
+// 		1, 2, 3, 1, 2, 1}))
+// 	println(findPeakElement([]int{
+// 		-67, -60, 78, 31, -24, -78, -89, 14, -18, 39, //   0~9
+// 		-4, 60, -33, 77, 48, 22, 88, -40, -83, 25, //     10~19
+// 		-55, 68, 61, -72, -77, 8, -11, 90, -75, -86, //   20~29
+// 		-85, -66, -79, 26, 30, 32, 81, 27, 12, 86, //     30~39
+// 		23, -41, 20, -58, 57, 10, 54, -27, -63, -94})) // 40~49
+// }

medium/165.go

@@ -0,0 +1,41 @@
+package main
+
+import (
+	"strconv"
+)
+
+func compareVersion(version1 string, version2 string) int {
+	idx1, idx2 := 0, 0
+	for idx1 < len(version1) || idx2 < len(version2) {
+		part1 := nextPartOfVersion(version1, &idx1)
+		part2 := nextPartOfVersion(version2, &idx2)
+		if part1 < part2 {
+			return -1
+		} else if part1 > part2 {
+			return 1
+		}
+	}
+	return 0
+}
+
+func nextPartOfVersion(version string, beg *int) int {
+	length := len(version)
+	if *beg >= length {
+		return 0
+	}
+	var end int
+	for end = *beg + 1; end < length; end++ {
+		if version[end] == '.' {
+			break
+		}
+	}
+	val, _ := strconv.Atoi(version[*beg:end])
+	*beg = end + 1
+	return val
+}
+
+// func main() {
+// 	println(compareVersion("1.0.1", "1"))
+// 	println(compareVersion("1.0.1", "2"))
+// 	println(compareVersion("1.0.0.0", "1"))
+// }

medium/166.go

@@ -0,0 +1,64 @@
+package main
+
+import (
+	"strconv"
+	"strings"
+)
+
+func fractionToDecimal(numerator int, denominator int) string {
+	isNegtive := (numerator > 0 && denominator < 0) ||
+		(numerator < 0 && denominator > 0)
+	numer, deno := int64(numerator), int64(denominator)
+	if isNegtive {
+		numer = absInt64(numer)
+		deno = absInt64(deno)
+	}
+	remainder := make(map[int64]int, 0) // 0 means not in dict yet
+	digits := make([]int64, 0)
+	remain := numer % deno
+	digit := numer / deno
+	for remainder[remain] == 0 {
+		digits = append(digits, digit)
+		remainder[remain] = len(digits)
+		remain *= 10
+		digit = remain / deno
+		remain %= deno
+	}
+	if digit != 0 {
+		digits = append(digits, digit)
+	}
+	var sb strings.Builder
+	sb.WriteString(strconv.Itoa(int(digits[0])))
+	hasLoop := false
+	for i := 1; i < len(digits); i++ {
+		if i == 1 {
+			sb.WriteByte('.')
+		}
+		if i == remainder[remain] {
+			sb.WriteByte('(')
+			hasLoop = true
+		}
+		sb.WriteByte(byte(digits[i]) + '0')
+	}
+	if hasLoop {
+		sb.WriteByte(')')
+	}
+	if isNegtive {
+		return "-" + sb.String()
+	}
+	return sb.String()
+}
+
+func absInt64(x int64) int64 {
+	if x < 0 {
+		return -int64(x)
+	}
+	return int64(x)
+}
+
+func main() {
+	println(fractionToDecimal(-1, -2147483648))
+	println(fractionToDecimal(-50, 8))
+	println(fractionToDecimal(2, 1))
+	println(fractionToDecimal(0, -5))
+}

medium/173.js

@@ -0,0 +1,73 @@
+'use strict'
+
+/**
+ * Definition for binary tree
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+
+function TreeNode(val) {
+    this.val = val;
+    this.left = this.right = null;
+}
+
+/**
+ * @constructor
+ * @param {TreeNode} root - root of the binary search tree
+ */
+var BSTIterator = function (root) {
+
+}
+
+/**
+ * @this BSTIterator
+ * @returns {boolean} - whether we have a next smallest number
+ */
+BSTIterator.prototype.hasNext = function () {
+
+}
+
+/**
+ * @this BSTIterator
+ * @returns {number} - the next smallest number
+ */
+BSTIterator.prototype.next = function () {
+
+}
+
+/**
+ * Your BSTIterator will be called like this:
+ * var i = new BSTIterator(root), a = [];
+ * while (i.hasNext()) a.push(i.next());
+ */
+
+function __main__() {
+    /* eslit no-console: ["error", {"allow": ["log"]}] */
+    const logger = console.log.bind(console)
+    //       1
+    //      / \
+    //     2   3
+    //    /    /\
+    //   4    6  7
+    const n7 = new TreeLinkNode(7)
+    const n6 = new TreeLinkNode(6)
+    const n4 = new TreeLinkNode(4)
+    const n3 = new TreeLinkNode(3)
+    n3.left = n6
+    n3.right = n7
+    const n2 = new TreeLinkNode(2)
+    n2.left = n4
+    const n1 = new TreeLinkNode(1)
+    n1.left = n2
+    n1.right = n3
+    const i = new BSTIterator(n1)
+    const a = []
+    while (i.hasNext()) {
+        a.push(i.next())
+    }
+    logger(a)
+}
+
+__main__()