Refine 868 and add link

Author: qiyuangong

README.md

@@ -205,6 +205,7 @@ I'm currently working on [Analytics-Zoo](https://github.com/intel-analytics/anal
 | 844 | [Backspace String Compare](https://leetcode.com/problems/backspace-string-compare/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/844_Backspace_String_Compare.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/844_Backspace_String_Compare.java) | 1. Stack pop when encounters #, O(n) and O(n)<br>2. Compare string from end to start, O(n) and O(1) |
 | 852 | [Peak Index in a Mountain Array](https://leetcode.com/problems/peak-index-in-a-mountain-array/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/852_Peak_Index_in_a_Mountain_Array.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/852_Peak_Index_in_a_Mountain_Array.java) | 1. Scan the array until encountering decline, O(n) and O(1)<br>2. Binary seach with additional check for [i + 1], O(logn) and O(1) |
 | 867 | [Transpose Matrix](https://leetcode.com/problems/transpose-matrix/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/867_Transpose_Matrix.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/867_Transpose_Matrix.java) | Res[i][j] = A[j][i] |
+| 868 | [Binary Gap](https://leetcode.com/problems/binary-gap/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/868_Binary_Gap.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/868_Binary_Gap.java) |  1. Store index and check, O(logn) and O(logn)<br>2. One pass and store max, O(logn) and O(1) |
 | 872 | [Leaf-Similar Trees](https://leetcode.com/problems/leaf-similar-trees/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/872_Leaf-Similar_Trees.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/872_Leaf-Similar_Trees.java) | DFS (stack or recursion) get leaf value sequence and compare, O(n) and O(n) |
 | 876 | [Middle of the Linked List](https://leetcode.com/problems/middle-of-the-linked-list/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/876_Middle_of_the_Linked_List.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/876_Middle_of_the_Linked_List.java) | 1. Copy to array, O(n) and O(n)<br>2. Fast and slow point, where fast point is 2 times faster than slow point, O(n) and O(1) |
 | 904 | [Fruit Into Baskets](https://leetcode.com/problems/fruit-into-baskets/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/904_Fruit_Into_Baskets.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/904_Fruit_Into_Baskets.java) | 1. Scan through blocks of tree, O(n) and O(n)<br>2. Mainten a sliding window with start and curr point, O(n) and O(n). |

java/868_Binary_Gap.java

@@ -0,0 +1,27 @@
+class Solution {
+    /*public int binaryGap(int n) {
+        // Store Indexes
+        int[] A = new int[32];
+        int t = 0;
+        for (int i = 0; i < 32; ++i)
+            if (((N >> i) & 1) != 0)
+                A[t++] = i;
+
+        int ans = 0;
+        for (int i = 0; i < t - 1; ++i)
+            ans = Math.max(ans, A[i+1] - A[i]);
+        return ans;
+    }*/
+
+    public int binaryGap(int N) {
+        int last = -1, ans = 0;
+        for (int i = 0; i < 32; ++i)
+            if (((N >> i) & 1) > 0) {
+                // Store max
+                if (last >= 0)
+                    ans = Math.max(ans, i - last);
+                last = i;
+            }
+        return ans;
+    }
+}

python/868_Binary_Gap.py

@@ -1,14 +1,34 @@
 class Solution:
+
+    # def binaryGap(self, n: int) -> int:
+    #     # Store index
+    #     A = [i for i in xrange(32) if (N >> i) & 1]
+    #     if len(A) < 2: return 0
+    #     return max(A[i+1] - A[i] for i in xrange(len(A) - 1))
+
+
     def binaryGap(self, n: int) -> int:
-        current= 1
+        # one pass and store max
+        current = 1
         last1 = -1
         out = 0
         while n > 0:
-            if n%2 == 1:
+            if n % 2 == 1:
                 if last1 >= 1:
                     out = max(out, current - last1)
                 last1 = current
             current += 1
-            n = n//2
-        return(out)
-        
+            n = n // 2
+        return out
+    
+    # def binaryGap(self, n: int) -> int:
+    #     # one pass and store max
+    #     res = 0
+    #     last = -1
+    #     # Get binary encoding with bin
+    #     for i, curr in enumerate(bin(n)[2:]):
+    #         if curr == '1':
+    #             if last >= 0:
+    #                 res = max(res, i - last)
+    #             last = i
+    #     return res