update

easy/268.missing-number.go

@@ -0,0 +1,7 @@
+func missingNumber(nums []int) int {
+	n, sum := len(nums), 0
+	for _, i := range nums {
+		sum += i
+	}
+	return (n+1)*n/2 - sum
+}

easy/278.first-bad-version.js

@@ -0,0 +1,33 @@
+/**
+ * Definition for isBadVersion()
+ * 
+ * @param {integer} version number
+ * @return {boolean} whether the version is bad
+ * isBadVersion = function(version) {
+ *     ...
+ * };
+ */
+
+/**
+ * @param {function} isBadVersion()
+ * @return {function}
+ */
+var solution = function(isBadVersion) {
+    /**
+     * @param {integer} n Total versions
+     * @return {integer} The first bad version
+     */
+    return function(n) {
+        let beg = 1, end = n, gap = 0
+		while (beg < end) {
+			if (gap == end - beg) break
+			gap = end - beg
+			let mid = Math.round((beg + end) / 2)
+			let isBad = isBadVersion(mid)
+			if (isBad) end = mid
+			else if (!isBad) beg = mid + 1
+		}
+		if (isBadVersion(beg)) return beg
+		return end
+    }
+}

easy/283.move-zeroes.go

@@ -0,0 +1,16 @@
+func moveZeroes(nums []int)  {
+	n := len(nums)
+	ptr, cnt := 0, 0
+	for i := 0; i < n && ptr < n-cnt; i++ {
+		if nums[i] == 0 {
+			cnt++
+		} else {
+			nums[ptr] = nums[i]
+			ptr++
+		}
+	}
+	for ptr < n {
+		nums[ptr] = 0
+		ptr++
+	}
+}

easy/290.word-pattern.go

@@ -0,0 +1,23 @@
+func wordPattern(pattern string, str string) bool {
+	words := strings.Split(str, " ")
+	if len(words) != len(pattern) {
+		return false
+	}
+	r2s := make(map[rune]string)
+	s2r := make(map[string]rune)
+	for i, p := range pattern {
+		if s, ok := r2s[p]; ok {
+			if s != words[i] {
+				return false
+			}
+		}
+		if r, ok := s2r[words[i]]; ok {
+			if r != p {
+				return false
+			}
+		}
+		r2s[p] = words[i]
+		s2r[words[i]] = p
+	}
+	return true
+}

easy/292.nim-game.go

@@ -0,0 +1,3 @@
+func canWinNim(n int) bool {
+	return n % 4 != 0
+}

medium/284.peeking-iterator.java

@@ -0,0 +1,32 @@
+// Java Iterator interface reference:
+// https://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html
+class PeekingIterator implements Iterator<Integer> {
+	private Iterator<Integer> iter;
+	private Integer peek;
+
+	public PeekingIterator(Iterator<Integer> iterator) {
+	    // initialize any member here.
+	    this.iter = iterator;
+	}
+
+    // Returns the next element in the iteration without advancing the iterator.
+	public Integer peek() {
+		if (this.peek == null) this.peek = this.iter.next();
+		return this.peek;
+	}
+
+	// hasNext() and next() should behave the same as in the Iterator interface.
+	// Override them if needed.
+	@Override
+	public Integer next() {
+		if (this.peek == null) return this.iter.next();
+		Integer next = this.peek;
+		this.peek = null;
+		return next;
+	}
+
+	@Override
+	public boolean hasNext() {
+		return peek != null || this.iter.hasNext();
+	}
+}

medium/300.longest-increasing-subsequence.go

@@ -1,4 +1,4 @@
-func lengthOfLIS(nums []int) int {
+func lengthOfLISSlow(nums []int) int {
 	n := len(nums)
 	if n <= 1 {
 		return n
@@ -8,17 +8,45 @@ func lengthOfLIS(nums []int) int {
 	for i := 1; i < n; i *= 2 {
 		copy(lis[i:], lis[:i])
 	}
+	max := 1
 	for i := 1; i < n; i++ {
 		for j := 0; j < i; j++ {
 			if nums[j] < nums[i] && lis[i] < lis[j]+1 {
 				lis[i] = lis[j] + 1
+				if max < lis[i] {
+					max = lis[i]
+				}
 			}
 		}
 	}
-	max := lis[0]
+	return max
+}
+
+func lengthOfLIS(nums []int) int {
+	n := len(nums)
+	if n <= 1 {
+		return n
+	}
+	lis := []int{nums[0]}
+	max := 1
 	for i := 1; i < n; i++ {
-		if max < lis[i] {
-			max = lis[i]
+		if lis[max-1] < nums[i] {
+			lis = append(lis, nums[i]) // O(nlog(n)), maintain the smallest LIS only
+			max++
+		} else {
+			beg, end := 0, max
+			for beg < end {
+				mid := beg + (end-beg)/2
+				if lis[mid] < nums[i] {
+					beg = mid + 1
+				} else if nums[i] < lis[mid] {
+					end = mid
+				} else {
+					beg = mid
+					break
+				}
+			}
+			lis[beg] = nums[i]
 		}
 	}
 	return max