nature1995
diff --git a/‎Python3/054_Spira_Matrix.py
Copy file name to clipboard
+61Lines changed: 61 additions & 0 deletions b/‎Python3/054_Spira_Matrix.py
Copy file name to clipboard
+61Lines changed: 61 additions & 0 deletions
diff --git a/‎Python3/055_Jump_Game.py
Copy file name to clipboard
+38Lines changed: 38 additions & 0 deletions b/‎Python3/055_Jump_Game.py
Copy file name to clipboard
+38Lines changed: 38 additions & 0 deletions
diff --git a/‎Python3/056_Merge_Intervals.py
Copy file name to clipboard
+46Lines changed: 46 additions & 0 deletions b/‎Python3/056_Merge_Intervals.py
Copy file name to clipboard
+46Lines changed: 46 additions & 0 deletions
@@ -0,0 +1,61 @@
+#!usr/bin/env python3
+# -*- coding:utf-8 -*-
+'''
+Given a matrix of m x n elements (m rows, n columns), return all elements of the matrix in spiral order.
+
+For example,
+Given the following matrix:
+
+[
+ [ 1, 2, 3 ],
+ [ 4, 5, 6 ],
+ [ 7, 8, 9 ]
+]
+You should return [1,2,3,6,9,8,7,4,5].
+'''
+
+
+class Solution(object):
+    def spiralOrder(self, matrix):
+        """
+        :type matrix: List[List[int]]
+        :rtype: List[int]
+        """
+        if not matrix:
+            return []
+        left = top = 0
+        right = len(matrix[0]) - 1
+        bottom = len(matrix) - 1
+        result = []
+        while left < right and top < bottom:
+            for i in range(left, right):
+                result.append(matrix[top][i])
+            for i in range(top, bottom):
+                result.append(matrix[i][right])
+            for i in range(right, left, -1):
+                result.append(matrix[bottom][i])
+            for i in range(bottom, top, -1):
+                result.append(matrix[i][left])
+            left += 1
+            right -= 1
+            top += 1
+            bottom -= 1
+        if right == left and top == bottom:
+            result.append(matrix[top][left])
+        elif right == left:
+            for i in range(top, bottom + 1):
+                result.append(matrix[i][left])
+        elif top == bottom:
+            for i in range(left, right + 1):
+                result.append(matrix[top][i])
+        return result
+
+
+if __name__ == "__main__":
+    assert Solution().spiralOrder([
+        [1, 2, 3],
+        [4, 5, 6],
+        [7, 8, 9]
+    ]) == [1, 2, 3, 6, 9, 8, 7, 4, 5]
+    assert Solution().spiralOrder([[2], [3]]) == [2, 3]
+    assert Solution().spiralOrder([[2, 3]]) == [2, 3]
@@ -0,0 +1,38 @@
+#!usr/bin/env python3
+# -*- coding:utf-8 -*-
+'''
+Given an array of non-negative integers, you are initially positioned at the first index of the array.
+
+Each element in the array represents your maximum jump length at that position.
+
+Determine if you are able to reach the last index.
+
+For example:
+A = [2,3,1,1,4], return true.
+
+A = [3,2,1,0,4], return false.
+'''
+
+
+class Solution(object):
+    def canJump(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: bool
+        """
+        if not nums:
+            return False
+        lenth = len(nums)
+        index = 0
+        longest = nums[0]
+        while index <= longest:
+            if longest >= lenth - 1:
+                return True
+            longest = max(longest, index + nums[index])
+            index += 1
+        return False
+
+
+if __name__ == "__main__":
+    assert Solution().canJump([2, 3, 1, 1, 4]) == True
+    assert Solution().canJump([3, 2, 1, 0, 4]) == False
@@ -0,0 +1,46 @@
+#!usr/bin/env python3
+# -*- coding:utf-8 -*-
+'''
+Given a collection of intervals, merge all overlapping intervals.
+
+For example,
+Given [1,3],[2,6],[8,10],[15,18],
+return [1,6],[8,10],[15,18].
+'''
+
+
+# Definition for an interval.
+class Interval(object):
+    def __init__(self, s=0, e=0):
+        self.start = s
+        self.end = e
+
+    # To print the result
+    def __str__(self):
+        return "[" + str(self.start) + "," + str(self.end) + "]"
+
+
+class Solution(object):
+    def merge(self, intervals):
+        """
+        :type intervals: List[Interval]
+        :rtype: List[Interval]
+        """
+        result = []
+        if not intervals:
+            return result
+        intervals.sort(key = lambda x : x.start)
+        result.append(intervals[0])
+        for interval in intervals[1:]:
+            prev = result[-1]
+            if prev.end >= interval.start:
+                prev.end = max(prev.end, interval.end)
+            else:
+                result.append(interval)
+        return result
+
+
+if __name__ == "__main__":
+    intervals = Solution().merge([Interval(1, 3), Interval(2, 6), Interval(8, 10), Interval(15, 18)])
+    for interval in intervals:
+        print(interval)