Add solutions

Author: lessfish

Algorithms/01 Matrix/01-matrix.js

@@ -0,0 +1,41 @@
+// Source : https://leetcode.com/problems/01-matrix/#/description
+// Author : Han Zichi
+// Date   : 2016-03-27
+
+/**
+ * @param {number[][]} matrix
+ * @return {number[][]}
+ */
+var updateMatrix = function(matrix) {
+  // BFS
+  let q = [];
+  let hash = [];
+  let [m, n] = [matrix.length, matrix[0].length];
+  const dir = [[1, 0], [-1, 0], [0, 1], [0, -1]];
+
+  for (let i = 0; i < m; i++) {
+    hash[i] = [];
+    for (let j = 0; j < n; j++) {
+      if (matrix[i][j] === 0) {
+        q.push({x: i, y: j, step: 0});
+        hash[i][j] = 0;
+      }
+    }
+  }
+
+  while (q.length) {
+    let item = q.shift();
+    let {x, y, step} = item;
+
+    for (let i = 0; i < 4; i++) {
+      let _x = x + dir[i][0];
+      let _y = y + dir[i][1];
+      if (_x < 0 || _x >= m || _y < 0 || _y >= n) continue;
+      if (hash[_x][_y] !== undefined) continue;
+      hash[_x][_y] = step + 1;
+      q.push({x: _x, y: _y, step: step + 1});
+    }
+  }
+
+  return hash;
+};

Algorithms/Complex Number Multiplication/complex-number-multiplication.py

@@ -0,0 +1,16 @@
+# Source : https://leetcode.com/problems/complex-number-multiplication/#/description
+# Author : Han Zichi
+# Date   : 2017-04-23
+
+class Solution(object):
+    def complexNumberMultiply(self, a, b):
+        """
+        :type a: str
+        :type b: str
+        :rtype: str
+        """
+        a = [int(i) for i in a[:-1].split('+')]
+        b = [int(i) for i in b[:-1].split('+')]
+        c = a[0] * b[0] - a[1] * b[1]
+        d = a[0] * b[1] + a[1] * b[0]
+        return str(c) + '+' + str(d) + 'i'

Algorithms/Convert BST to Greater Tree/convert-bst-to-greater-tree.py

@@ -0,0 +1,29 @@
+# Source : https://leetcode.com/problems/convert-bst-to-greater-tree/#/description
+# Author : Han Zichi
+# Date   : 2017-04-23
+
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def convertBST(self, root):
+        """
+        :type root: TreeNode
+        :rtype: TreeNode
+        """
+        def dfs(node):
+            if node == None:
+                return
+            else:
+                dfs(node.right)
+                node.val += dfs.total
+                dfs.total = node.val
+                dfs(node.left)
+
+        dfs.total = 0
+        dfs(root)
+        return root

Algorithms/Diameter of Binary Tree/diameter-of-binary-tree.py

@@ -0,0 +1,32 @@
+# Source : https://leetcode.com/problems/diameter-of-binary-tree/#/description
+# Author : Han Zichi
+# Date   : 2017-04-23
+
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def diameterOfBinaryTree(self, root):
+        """
+        :type root: TreeNode
+        :rtype: int
+        """
+        
+
+        def getHeight(node, depth):
+            if node == None:
+                return -1
+            else:
+                left = getHeight(node.left, depth) + 1
+                right = getHeight(node.right, depth) + 1
+                getHeight.ans = max(getHeight.ans, left + right)
+                return max(left, right)
+
+        getHeight.ans = 0
+        getHeight(root, 0)
+        
+        return getHeight.ans

Algorithms/Encode and Decode TinyURL/encode-and-decode-tinyurl.js

@@ -0,0 +1,40 @@
+// Source : https://leetcode.com/problems/encode-and-decode-tinyurl/
+// Author : Han Zichi
+// Date   : 2017-04-23
+
+let [p, index] = [new Map(), 0];
+
+var base62 = (n) => {
+  let str = '0123456789abcdefghigklmnopqrstuvwxyzABCDEFGHIGKLMNOPQRSTUVWXYZ';
+  let len = str.length;
+  let ret = '';
+
+  do {
+    ret += str[n % len];
+    n = ~~(n / len);
+  } while (n);
+
+  return ret;
+};
+
+/**
+ * Encodes a URL to a shortened URL.
+ *
+ * @param {string} longUrl
+ * @return {string}
+ */
+var encode = function(longUrl) {
+  let shortUrl = base62(index++);
+  p.set(shortUrl, longUrl);
+  return shortUrl;
+};
+
+/**
+ * Decodes a shortened URL to its original URL.
+ *
+ * @param {string} shortUrl
+ * @return {string}
+ */
+var decode = function(shortUrl) {
+  return p.get(shortUrl);
+};

Algorithms/Friend Circles/friend-circles.py

@@ -0,0 +1,26 @@
+# Source : https://leetcode.com/problems/friend-circles/#/description
+# Author : Han Zichi
+# Date   : 2017-04-23
+
+class Solution(object):
+    def findCircleNum(self, M):
+        """
+        :type M: List[List[int]]
+        :rtype: int
+        """
+        def dfs(index):
+            hash[index] = True
+            for index, item in enumerate(M[index]):
+                if hash[index] == False and item == 1:
+                    dfs(index)
+        
+        n = len(M)
+        ans = 0
+        hash = [False] * n 
+
+        for i in range(n):
+            if hash[i] == False:
+                ans += 1
+                dfs(i)
+
+        return ans

Algorithms/Insert Delete GetRandom O(1) - Duplicates allowed/insert-delete-getrandom-o1-duplicates-allowed.py

@@ -0,0 +1,47 @@
+# Source : https://leetcode.com/problems/insert-delete-getrandom-o1-duplicates-allowed/#/description
+# Author : Han Zichi
+# Date   : 2017-04-23
+
+import random
+class RandomizedCollection(object):
+
+    def __init__(self):
+        """
+        Initialize your data structure here.
+        """
+        self.s = []
+        
+
+    def insert(self, val):
+        """
+        Inserts a value to the collection. Returns true if the collection did not already contain the specified element.
+        :type val: int
+        :rtype: bool
+        """
+        if val in self.s:
+            self.s.append(val)
+            return False
+        else:
+            self.s.append(val)
+            return True 
+        
+
+    def remove(self, val):
+        """
+        Removes a value from the collection. Returns true if the collection contained the specified element.
+        :type val: int
+        :rtype: bool
+        """
+        if val in self.s:
+            self.s.remove(val)
+            return True 
+        else:
+            return False
+
+    def getRandom(self):
+        """
+        Get a random element from the collection.
+        :rtype: int
+        """
+        index = int(random.random() * len(self.s))
+        return self.s[index]

Algorithms/Insert Delete GetRandom O(1)/insert-delete-getrandom-o1.py

@@ -0,0 +1,48 @@
+# Source : https://leetcode.com/problems/insert-delete-getrandom-o1/#/description
+# Author : Han Zichi
+# Date   : 2017-04-23
+
+import random
+class RandomizedSet(object):
+
+    def __init__(self):
+        """
+        Initialize your data structure here.
+        """
+        self.s = set()
+
+
+    def insert(self, val):
+        """
+        Inserts a value to the set. Returns true if the set did not already contain the specified element.
+        :type val: int
+        :rtype: bool
+        """
+        if val in self.s:
+            return False
+        else:
+            self.s.add(val)
+            return True
+
+
+    def remove(self, val):
+        """
+        Removes a value from the set. Returns true if the set contained the specified element.
+        :type val: int
+        :rtype: bool
+        """
+        if val in self.s:
+            self.s.remove(val)
+            return True 
+        else:
+            return False
+
+
+    def getRandom(self):
+        """
+        Get a random element from the set.
+        :rtype: int
+        """
+        lis = list(self.s)
+        index = int(random.random() * len(lis))
+        return lis[index]

Algorithms/Longest Uncommon Subsequence I/longest-uncommon-subsequence-i.py

@@ -0,0 +1,18 @@
+# Source : https://leetcode.com/problems/longest-uncommon-subsequence-i/#/description
+# Author : Han Zichi
+# Date   : 2017-04-23
+
+class Solution(object):
+    def findLUSlength(self, a, b):
+        """
+        :type a: str
+        :type b: str
+        :rtype: int
+        """
+        if a == b:
+            return -1
+        if a.find(b) != -1:
+            return len(a)
+        if b.find(a) != -1:
+            return len(b)
+        return max(len(a), len(b))

Algorithms/Minimum Time Difference/minimum-time-difference.js

@@ -0,0 +1,24 @@
+// Source : https://leetcode.com/problems/minimum-time-difference/#/description
+// Author : Han Zichi
+// Date   : 2016-03-26
+
+/**
+ * @param {string[]} timePoints
+ * @return {number}
+ */
+var findMinDifference = function(timePoints) {
+  let helper = str => {
+    let arr = str.split(':');
+    return +arr[0] * 60 + (+arr[1]);
+  };
+
+  timePoints = timePoints.map(helper);
+  timePoints = [...timePoints, ...timePoints.map(item => item + 60 * 24)];
+  timePoints.sort((a, b) => a - b);
+
+  let ans = Infinity;
+  for (let i = 1, len = timePoints.length; i < len; i++)
+    ans = Math.min(ans, timePoints[i] - timePoints[i - 1]);
+
+  return ans;
+};

Algorithms/Perfect Number/perfect-number.py

@@ -0,0 +1,21 @@
+# Source : https://leetcode.com/problems/perfect-number/#/description
+# Author : Han Zichi
+# Date   : 2017-04-23
+
+import math
+class Solution(object):
+    def checkPerfectNumber(self, num):
+        """
+        :type num: int
+        :rtype: bool
+        """
+        if num <= 1:
+            return False
+
+        total = 1
+        end = int(math.sqrt(num))
+        for i in range(2, end + 1):
+            if num % i == 0:
+                total += i + num / i 
+
+        return total == num

Algorithms/Random Pick Index/random-pick-index.py

@@ -0,0 +1,27 @@
+# Source : https://leetcode.com/problems/random-pick-index/#/description
+# Author : Han Zichi
+# Date   : 2017-04-23
+
+import random
+class Solution(object):
+
+    def __init__(self, nums):
+        """
+        
+        :type nums: List[int]
+        :type numsSize: int
+        """
+        self.nums = nums
+
+    def pick(self, target):
+        """
+        :type target: int
+        :rtype: int
+        """
+        array = []
+        for index, item in enumerate(self.nums):
+            if item == target:
+                array.append(index)
+
+        index = int(random.random() * len(array))
+        return array[index]