Update ./topic to latest

Author: jaychsu

topic/bit_manipulation/README.md

@@ -29,3 +29,12 @@ output 1 if input 0
 >>> 0 ^ 1
 1
 ```
+
+## To check a number is power of 2
+
+if a number is power of 2, then there is only 1 in the bit format in the number.
+
+```python
+>>> [(num & (num - 1)) == 0 for num in (4, 5, 11, 16, 21, 29, 32)]
+[True, False, False, True, False, False, True]
+```

topic/complexity_analysis.md

@@ -21,3 +21,24 @@ for (int i = N; i > 0; i /= 2) {
 
 If X will always be a better choice for **large inputs**,
 then we say that **an algorithm X is asymptotically more efficient than Y**.
+
+## Case #3
+
+- time: `O(N)`
+- the `j` go through that array only once.
+
+```java
+int j = 0;
+for(int i = 0; i < n; ++i) {
+  while(j < n && arr[i] < arr[j]) {
+    j++;
+  }
+}
+```
+
+## Case #4
+
+- time: `O(2 ^ N)`
+- REF: https://math.stackexchange.com/questions/177405/prove-by-induction-2n-cn-0-cn-1-cdots-cn-n
+
+`C(n, 0) + C(n, 1) + ... + C(n, n) = 2 ^ n`

topic/hash/python/geohash.py

@@ -1,12 +1,18 @@
 """
-main concept for encoding
-
-1. use binary search to convert `lng` and `lat` to `bin_code`
-   `1`: up or right
-   `0`: down or left
-2. merge `lng_codes` and `lat_codes` alternately into one `bin_codes`
-   `lng_codes[0] + lat_codes[0] + lng_codes[1] + ...`
-3. pick every 5 digit from `bin_codes` and convert that to `base32`
+REF:
+
+- lintcode/529_geohash.py
+- lintcode/530_geohash_ii.py
+
+
+Main Concept: for encoding
+
+1. use binary search to convert `lng` and `lat` to `bincode`
+   1: up or right
+   0: down or left
+2. merge `lngcode` and `latcode` alternately into one `bincode`
+   `lngcode[0] + latcode[0] + lngcode[1] + ...`
+3. pick every 5 digit from `bincode` and convert that to base32 chars
 """
 
 

topic/heap/python/binary_hash_heap.py

@@ -92,8 +92,8 @@ def _siftup(self, i):
         while i * 2 <= size:
             j = i * 2
 
-            if i * 2 + 1 <= size and heap[i * 2 + 1] < heap[i * 2]:
-                j = i * 2 + 1
+            if j + 1 <= size and heap[j + 1] < heap[j]:
+                j += 1
 
             if heap[i] > heap[j]:
                 self._swap(i, j)

topic/heap/python/binary_heap.py

@@ -68,8 +68,8 @@ def _siftup(self, i):
         while i * 2 <= size:
             j = i * 2
 
-            if i * 2 + 1 <= size and heap[i * 2 + 1] < heap[i * 2]:
-                j = i * 2 + 1
+            if j + 1 <= size and heap[j + 1] < heap[j]:
+                j += 1
 
             if heap[i] > heap[j]:
                 heap[i], heap[j] = heap[j], heap[i]

topic/problem_set/subarray_sum.md

@@ -0,0 +1,30 @@
+## Differences
+
+`leetcode/209_minimum_size_subarray_sum.py`
+
+- elements is non-negative
+- sum >= k
+- find min length
+
+`leetcode/325_maximum_size_subarray_sum_equals_k.py`
+
+- elements may be negative
+- sum == k
+- find max length
+
+`leetcode/560_subarray_sum_equals_k.py`
+
+- elements may be negative
+- sum == k
+- count how many subarrays
+
+`leetcode/862_shortest_subarray_with_sum_at_least_k.py`
+
+- elements may be negative
+- sum >= k
+- find min length
+
+## Solutions
+
+- Non-negative => Two Pointers
+- Negative => Prefix Sum

topic/tree/python/binary_tree.py

@@ -6,66 +6,64 @@ def __init__(self, val):
 
 class BinaryTree:
     EMPTY = '#'
+    TMPL = '{{{}}}'  # {{, }} is to escape brackets
 
     @classmethod
     def serialize(cls, root):
         """Encodes a tree to a single string.
         :type root: TreeNode
         :rtype: str
         """
-        TEMPLATE = '{{{}}}'  # {{, }} is to escape brackets
         if not root:
-            return TEMPLATE.format('')
+            return cls.TMPL.format('')
 
-        vals = []
+        values = []
         queue = [root]
 
         for node in queue:
             if not node:
-                vals.append(cls.EMPTY)
+                values.append(cls.EMPTY)
                 continue
 
-            vals.append(str(node.val))
+            values.append(str(node.val))
             queue.append(node.left)
             queue.append(node.right)
 
-        while vals[-1] == cls.EMPTY:
-            vals.pop()
+        while values[-1] == cls.EMPTY:
+            values.pop()
 
-        return TEMPLATE.format(','.join(vals))
+        return cls.TMPL.format(','.join(values))
 
     @classmethod
     def deserialize(cls, data):
         """Decodes your encoded data to tree.
         :type data: str
         :rtype: TreeNode
         """
-        if (
-            not data or
-            data[0] != '{' or
-            data[-1] != '}' or
-            len(data) < 3 or
-            data[1] == cls.EMPTY
-        ):
+        if any((
+            not data,
+            len(data) < 3,
+            data[0] != '{',
+            data[-1] != '}',
+            data[1] in (cls.EMPTY, ','),
+        )):
             return
 
-        vals = data[1:-1].split(',')
-        n = len(vals)
+        values = data[1:-1].split(',')
         i = 0
-
-        root = TreeNode(int(vals[i]))
+        root = TreeNode(int(values[i]))
         queue = [root]
 
         for node in queue:
             for branch in ('left', 'right'):
                 i += 1
 
-                if i >= n:
+                if i >= len(values):
                     break
-                if vals[i] == cls.EMPTY:
+                if values[i] == cls.EMPTY:
                     continue
 
-                setattr(node, branch, TreeNode(int(vals[i])))
+                setattr(node, branch, TreeNode(int(values[i])))
                 queue.append(getattr(node, branch))
 
         return root