add some solutions

Author: Jack

Diff for: Python/implement-strstr.py

@@ -43,6 +43,17 @@ def getPrefix(self, pattern):
                 j += 1
             prefix[i] = j
         return prefix
+
+    def strStr2(self, haystack, needle):
+        """
+        :type haystack: str
+        :type needle: str
+        :rtype: int
+        """
+        try:
+            return haystack.index(needle)
+        except:
+            return -1
 
 # Time:  O(n * k)
 # Space: O(k)

Diff for: Python/jump-game-ii.py

@@ -13,6 +13,7 @@
 # The minimum number of jumps to reach the last index is 2. (Jump 1 step from index 0 to 1, then 3 steps to the last index.)
 #
 
+# not pass on leetcode because of time limit
 class Solution:
     # @param A, a list of integers
     # @return an integer
@@ -29,6 +30,7 @@ def jump(self, A):
             reachable = max(reachable, i + length)
         return jump_count
 
+# not pass on leetcode because of time limit
 # Time:  O(n^2)
 # Space: O(1)     
 class Solution2:
@@ -44,6 +46,31 @@ def jump(self, A):
             for i, length in enumerate(A[:reachable + 1]):
                 reachable = max(reachable, i + length)
         return -1
+
+# when you on an index of nums, move to next index which can move farthest in range of this index reachable
+# Time: O(log(n))
+# Space: O(1)
+class Solution3(object):
+    def jump(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        nums2, l = [i + j for i, j in enumerate(nums)], len(nums) - 1
+        if not l: return 0
+
+        def find_max_index(index):
+            if index + nums[index] >= l: return l
+            tmp = nums2[index + 1:index + nums[index] + 1]
+            return index + tmp.index(max(tmp)) + 1
+
+        index, steps = 0, 0
+        while True:
+            index = find_max_index(index)
+            steps += 1
+            if index == l:
+                break
+        return steps
 
 if __name__ == "__main__":
     print Solution().jump([2,3,1,1,4])

Diff for: Python/majority-element-ii.py

@@ -4,6 +4,8 @@
 # Given an integer array of size n, 
 # find all elements that appear more than [n/3] times. 
 # The algorithm should run in linear time and in O(1) space.
+import collections
+
 
 class Solution(object):
     def majorityElement(self, nums):
@@ -41,3 +43,10 @@ def majorityElement(self, nums):
                 result.append(i)
 
         return result
+
+    def majorityElement2(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: List[int]
+        """
+        return [i[0] for i in collections.Counter(nums).items() if i[1] > len(nums) / 3]

Diff for: Python/majority-element.py

@@ -5,24 +5,34 @@
 # The majority element is the element that appears more than [n/2] times.
 # 
 # You may assume that the array is non-empty and the majority element always exist in the array.
-#
+import collections
+
 
 class Solution:
-    # @param num, a list of integers
-    # @return an integer
-    def majorityElement(self, num):
+    def majorityElement(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
         idx, cnt = 0, 1
 
-        for i in xrange(1, len(num)):
-            if num[idx] == num[i]:
+        for i in xrange(1, len(nums)):
+            if nums[idx] == nums[i]:
                 cnt += 1
             else:
                 cnt -= 1
                 if cnt == 0:
                     idx = i
                     cnt = 1
 
-        return num[idx]
+        return nums[idx]
+
+    def majorityElement2(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        return sorted(collections.Counter(nums).items(), key=lambda a: a[1], reverse=True)[0][0]
 
 if __name__ == "__main__":
     print Solution().majorityElement([1, 2, 3, 4, 5, 5, 5, 5, 5, 5, 6])

Diff for: Python/repeated-dna-sequences.py

@@ -12,7 +12,8 @@
 #
 # Return:
 # ["AAAAACCCCC", "CCCCCAAAAA"].
-#
+import collections
+
 
 class Solution:
     # @param s, a string
@@ -29,6 +30,17 @@ def findRepeatedDnaSequences(self, s):
                 dict[rolling_hash] = False
         return res
 
+    def findRepeatedDnaSequences2(self, s):
+        """
+        :type s: str
+        :rtype: List[str]
+        """
+        l, r = [], []
+        if len(s) < 10: return []
+        for i in range(len(s) - 9):
+            l.extend([s[i:i + 10]])
+        return [k for k, v in collections.Counter(l).items() if v > 1]
+
 if __name__ == "__main__":
     print Solution().findRepeatedDnaSequences("AAAAAAAAAA")
     print Solution().findRepeatedDnaSequences("")