Merge branch 'master' of https://github.com/jcp0578/practise-Python

Author: jcp0578

.vscode/launch.json

@@ -10,12 +10,15 @@
             "request": "launch",
             "program": "${file}",
             "console": "none",
+<<<<<<< HEAD
             "args": [
                 "${file}"
             ],
 
 
 
+=======
+>>>>>>> bcaaeef0772a5a5e51387d27dd6c3407a2be148b
         },
         {
             "name": "Python: Attach",

leecode/Search a 2D Matrix II/searchMatrix.py

@@ -0,0 +1,83 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+'''
+AC
+'''
+
+import time
+
+
+class Solution:
+    def searchMatrix(self, matrix, target):
+        """
+        :type matrix: List[List[int]]
+        :type target: int
+        :rtype: bool
+        """
+        if not matrix or not matrix[0]:
+            return False
+        len_m = len(matrix)
+        for i in range(len_m):
+            if matrix[i][0]>target:
+                break
+            elif matrix[i][-1]>=target and matrix[i][0] <= target:
+                try:
+                    matrix[i].index(target)
+                    return True
+                except ValueError:
+                    pass
+        return False
+
+
+if __name__ == "__main__":
+
+    t0 = time.perf_counter()
+
+    test_list = [[
+        [1, 4, 7, 11, 15],
+        [2, 5, 8, 12, 19],
+        [3, 6, 9, 16, 22],
+        [10, 13, 14, 17, 24],
+        [18, 21, 23, 26, 30],
+    ], [[4, 5, 6, 7, 8, 9, 21]], [[]]]
+    test_list_2 = [17, 6, 1]
+    answer_list = [True, True, False]
+
+    test = Solution()
+    for i in range(len(test_list)):
+        out_t = test.searchMatrix(test_list[i], test_list_2[i])
+
+        if out_t == answer_list[i]:
+            print("\033[1;32;40m  Pass \033[0m")
+        else:
+            print(
+                "\033[1;31;40m  Fail!!\033[0m\033[0;34;40m out \"%s\" should \"%s\" by \"%.50s\" "
+                % (out_t, answer_list[i], test_list[i]))
+
+    print("\nRun Time is %f s" % (time.perf_counter() - t0))
+
+'''
+class Solution:
+    def searchMatrix(self, matrix, target):
+        """
+        :type matrix: List[List[int]]
+        :type target: int
+        :rtype: bool
+        """
+        if len(matrix)==0 or len(matrix[0])==0:
+            return False
+        for i in range(len(matrix)):
+            if target==matrix[i][-1] or target==matrix[i][0]:
+                return True
+            elif target<matrix[i][-1] and target>matrix[i][0]:
+                left,right=0,len(matrix[i])-1
+                while left<=right:
+                    mid=(left+right)//2
+                    if target==matrix[i][mid]:
+                        return True
+                    elif target>matrix[i][mid]:
+                        left=mid+1
+                    else:
+                        right=mid-1
+        return False
+'''

leecode/不同路径/uniquePaths.py

@@ -0,0 +1,93 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+'''
+AC
+'''
+
+import time
+
+
+class Solution:
+    def uniquePaths(self, m, n):
+        """
+        :type m: int
+        :type n: int
+        :rtype: int
+        """
+        if m < 1 or n < 1:  
+            return 0
+        record = [[1]*n for j in range(m)]  
+        for i in range(1, m):  
+            for j in range(1, n):  
+                record[i][j] = record[i - 1][j] + record[i][j - 1]  
+        return record[m - 1][n - 1]  
+
+
+if __name__ == "__main__":
+
+    t0 = time.perf_counter()
+
+    test_list = [3, 7, 23]
+    test_list_2 = [2, 3, 12]
+    answer_list = [3, 28, 193536720]
+
+    test = Solution()
+    for i in range(len(test_list)):
+        out_t = test.uniquePaths(test_list[i], test_list_2[i])
+
+        if out_t == answer_list[i]:
+            print("\033[1;32;40m  Pass \033[0m")
+        else:
+            print(
+                "\033[1;31;40m  Fail!!\033[0m\033[0;34;40m out \"%s\" should \"%s\" by \"%.50s\" "
+                % (out_t, answer_list[i],
+                   str(test_list[i]) + " " + str(test_list_2[i])))
+
+    print("\nRun Time is %f s" % (time.perf_counter() - t0))
+
+'''
+
+class Solution:
+    def uniquePaths(self, m, n):
+        """
+        :type m: int
+        :type n: int
+        :rtype: int
+        超时C(m + n - 2, n - 1)：
+        if m < n :
+            m,n = n,m
+        combins = [c for c in  itertools.combinations(range(m+n-2), n-1)]
+        out = len(combins)
+        return out
+        
+        from functools import reduce
+        if m < n:
+            m, n = n, m
+        mul = lambda x, y: reduce(operator.mul, range(x, y), 1)
+        return int(mul(m, m + n - 1) / mul(1, n))
+        """
+        v = [[1] * n for x in range(m) ]
+        for i in range(m):
+            for j in range(n):
+                if i >= 1 and j >= 1:
+                    v[i][j] = v[i][j-1]+v[i-1][j]
+        return v[m-1][n-1]
+
+
+class Solution:
+    def uniquePaths(self, m, n):
+        """
+        :type m: int
+        :type n: int
+        :rtype: int
+        """
+        dp = [0 for col in range(n)]
+        for i in range(n):
+            dp[i] = 1
+            
+        for i in range(1,m):
+            for j in range(1,n):
+                dp[j] = dp[j-1] + dp[j]
+        
+        return dp[n-1]
+'''

leecode/分类颜色/sortColors.py

@@ -0,0 +1,66 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+'''
+AC
+'''
+
+import time
+
+
+class Solution:
+    def sortColors(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: void Do not return anything, modify nums in-place instead.
+        """
+        if nums == []:
+            return nums
+        len_t = len(nums)
+        front_pos = 0
+
+        # while front_pos < len_t and nums[front_pos] == 0:
+        #     front_pos += 1
+
+        back_pos = len_t - 1
+        # while back_pos > 0 and nums[back_pos] == 2:
+        #     back_pos -= 1
+
+        i = front_pos
+        while i <= back_pos:
+            temp = nums[i]
+            if temp == 0:
+                nums[front_pos], nums[i] = nums[i], nums[front_pos]
+                front_pos += 1
+                i += 1
+            elif temp == 2:
+                nums[back_pos], nums[i] = nums[i], nums[back_pos]
+                back_pos -= 1
+                # while back_pos > 0 and nums[back_pos] == 2:
+                #     back_pos -= 1
+            else:
+                i+=1
+
+
+if __name__ == "__main__":
+
+    t0 = time.perf_counter()
+
+    test_list = [[2, 0, 2, 1, 1, 0], [0,2,2,2,0,1,1],[]]
+    answer_list = [[0, 0, 1, 1, 2, 2], [0,0,1,1,2,2,2],[]]
+    test = Solution()
+    for i in range(len(test_list)):
+        test.sortColors(test_list[i])
+        out_t = test_list[i]
+        if out_t == answer_list[i]:
+            print("\033[1;32;40m  Pass \033[0m")
+        else:
+            print(
+                "\033[1;31;40m  Fail!!\033[0m\033[0;34;40m out \"%s\" should \"%s\" by \"%.50s\" "
+                % (out_t, answer_list[i], test_list[i]))
+
+    print("\nRun Time is %f s" % (time.perf_counter() - t0))
+
+
+'''
+I think my solution is best,hhh
+'''

leecode/合并区间/merge.py

@@ -0,0 +1,96 @@
+#!/usr/bin/python3
+# -*- coding: utf-8 -*-
+'''
+AC 
+'''
+
+import time
+
+
+# Definition for an interval.
+class Interval:
+    def __init__(self, s=0, e=0):
+        self.start = s
+        self.end = e
+
+
+class Solution:
+    def merge(self, intervals):
+        """
+        :type intervals: List[Interval]
+        :rtype: List[Interval]
+        """
+        out_t = []
+        intervals.sort(key=lambda x: x.start)
+        for val in intervals:
+            if not out_t or val.start > out_t[-1].end:
+                out_t.append(val)
+            else:
+                out_t[-1].end = max(val.end,out_t[-1].end)
+        return out_t
+
+
+if __name__ == "__main__":
+
+    t0 = time.perf_counter()
+
+    test_list = [[[1, 3], [15, 18], [2, 6], [8, 10]], [[1, 4], [10, 15],
+                                                       [2, 12]], []]
+    answer_list = [[[1, 6], [8, 10], [15, 18]], [[1, 15]], []]
+    test = Solution()
+    for i in range(len(test_list)):
+        test_par = []
+        for list_t in test_list[i]:
+            test_par.append(Interval(list_t[0], list_t[1]))
+        out_t = test.merge(test_par)
+        out_tt = []
+        for out_interval in out_t:
+            out_tt.append([out_interval.start, out_interval.end])
+        if out_tt == answer_list[i]:
+            print("\033[1;32;40m  Pass \033[0m")
+        else:
+            print(
+                "\033[1;31;40m  Fail!!\033[0m\033[0;34;40m out \"%s\" should \"%s\" by \"%.50s\" "
+                % (out_tt, answer_list[i], test_list[i]))
+
+    print("\nRun Time is %f s" % (time.perf_counter() - t0))
+'''
+    def merge(self, intervals):
+        """
+        :type intervals: List[Interval]
+        :rtype: List[Interval]
+        """
+        n = len(intervals)
+        starts = []
+        ends = []
+        for i in range(n):
+            starts.append(intervals[i].start)
+            ends.append(intervals[i].end)
+        
+        starts.sort();  
+        ends.sort();  
+        res = []
+        j=0
+        for i in range(n):
+            if i == n - 1 or starts[i + 1] > ends[i]:
+                res.append([starts[j], ends[i]]) 
+                j = i + 1;  
+        return res;  
+
+class Solution:
+    def merge(self, intervals):
+        intervals.sort(key=lambda x: x.start)
+
+        merged = []
+        for interval in intervals:
+            # if the list of merged intervals is empty or if the current
+            # interval does not overlap with the previous, simply append it.
+            if not merged or merged[-1].end < interval.start:
+                merged.append(interval)
+            else:
+            # otherwise, there is overlap, so we merge the current and previous
+            # intervals.
+                merged[-1].end = max(merged[-1].end, interval.end)
+        
+        return merged
+'''