Initial commit

.idea/.gitignore

+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

.idea/inspectionProfiles/Project_Default.xml

+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="PyPep8NamingInspection" enabled="true" level="WEAK WARNING" enabled_by_default="true">
+      <option name="ignoredErrors">
+        <list>
+          <option value="N802" />
+        </list>
+      </option>
+    </inspection_tool>
+    <inspection_tool class="PyUnresolvedReferencesInspection" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="ignoredIdentifiers">
+        <list>
+          <option value="socketio.*" />
+        </list>
+      </option>
+    </inspection_tool>
+  </profile>
+</component>
\ No newline at end of file

.idea/inspectionProfiles/profiles_settings.xml

+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>
\ No newline at end of file

.idea/misc.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.9 (py36tf1)" project-jdk-type="Python SDK" />
+</project>
\ No newline at end of file

.idea/modules.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/python-algorithm.iml" filepath="$PROJECT_DIR$/.idea/python-algorithm.iml" />
+    </modules>
+  </component>
+</project>
\ No newline at end of file

.idea/python-algorithm.iml

+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="jdk" jdkName="Python 3.9 (py36tf1)" jdkType="Python SDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>
\ No newline at end of file

.idea/vcs.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>
\ No newline at end of file

01-数组/day01/problem_solving_01.py

+"""
+01.两数之和
+"""
+
+from typing import List
+
+
+class Solution:
+
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        """
+        两数之和
+        :param nums: 提供的数组
+        :param target: 目标值
+        :return: 返回值
+        """
+        hashmap = {}  # 字典不可以重复
+        for index, num in enumerate(nums):  # enumerate迭代返回index和value
+            hashmap[num] = index  # 解决value重复的问题
+
+        print(hashmap)
+        for i, num in enumerate(nums):
+            j = hashmap.get(target - num)
+            if j is not None and i != j:
+                return [i, j]
+
+
+if __name__ == '__main__':
+    s = Solution()
+    li = s.twoSum([2, 7, 11, 15], 9)
+    print(li)

01-数组/day01/problem_solving_02.py

+"""
+26. 删除有序数组中的重复项
+给你一个 升序排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。然后返回 nums 中唯一元素的个数。
+
+考虑 nums 的唯一元素的数量为 k ，你需要做以下事情确保你的题解可以被通过：
+
+更改数组 nums ，使 nums 的前 k 个元素包含唯一元素，并按照它们最初在 nums 中出现的顺序排列。nums 的其余元素与 nums 的大小不重要。
+返回 k 。
+判题标准:
+
+系统会用下面的代码来测试你的题解:
+
+int[] nums = [...]; // 输入数组
+int[] expectedNums = [...]; // 长度正确的期望答案
+
+int k = removeDuplicates(nums); // 调用
+
+assert k == expectedNums.length;
+for (int i = 0; i < k; i++) {
+    assert nums[i] == expectedNums[i];
+}
+如果所有断言都通过，那么您的题解将被 通过。
+
+
+
+示例 1：
+
+输入：nums = [1,1,2]
+输出：2, nums = [1,2,_]
+解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。
+示例 2：
+
+输入：nums = [0,0,1,1,1,2,2,3,3,4]
+输出：5, nums = [0,1,2,3,4]
+解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。
+
+
+提示：
+
+1 <= nums.length <= 3 * 104
+-104 <= nums[i] <= 104
+nums 已按 升序 排列
+"""
+from typing import List
+
+
+class Solution:
+    def removeDuplicates(self, nums: List[int]) -> int:
+        if not nums:
+            return 0
+        k = 1
+        for i in range(1, len(nums)):
+            if nums[i] != nums[i - 1]:
+                nums[k] = nums[i]
+                k += 1
+        return k
+
+
+if __name__ == '__main__':
+    s = Solution()
+    li = s.removeDuplicates([0, 0, 1, 1, 1, 2, 2, 3, 3, 4])
+    print(li)

01-数组/day01/problem_solving_03.py

+"""
+移除元素
+"""
+from typing import List
+
+
+class Solution:
+    def removeElement(self, nums: List[int], val: int) -> int:
+        """
+        左指针 单指针遍历
+        :param nums:
+        :param val:
+        :return:
+        """
+        left = 0
+        for index in range(0, len(nums)):
+            if nums[index] != val:
+                nums[left] = nums[index]
+                left += 1
+        return left
+
+    def removeElement2(self, nums: List[int], val: int) -> int:
+        """
+        双指针优化,左右夹逼
+        :param nums:
+        :param val:
+        :return:
+        """
+        left = 0
+        right = len(nums)
+        while left < right:
+            if nums[left] == val:
+                nums[left] = nums[right - 1]
+                right -= 1
+            else:
+                left += 1
+        return left
+
+
+if __name__ == '__main__':
+    result = Solution().removeElement2([2], 3)
+    print(result)

01-数组/day01/problem_solving_04.py

+"""
+搜索插入位置
+"""
+from typing import List
+
+
+class Solution:
+    def searchInsert(self, nums: List[int], target: int) -> int:
+        """
+        双指针
+        :param nums:
+        :param target:
+        :return:
+        """
+        left, right = 0, len(nums) - 1
+        while left <= right:
+            mid = (left + right) // 2
+            if nums[mid] == target:
+                return mid
+            elif nums[mid] < target:
+                left += 1
+            else:
+                right -= 1
+        return left
+
+    def searchInsert2(self, nums: List[int], target: int) -> int:
+        """
+        双指针
+        :param nums:
+        :param target:
+        :return:
+        """
+        left, right = 0, len(nums) - 1
+        while left <= right:
+            mid = (left + right) // 2
+            if nums[mid] == target:
+                return mid
+            elif nums[mid] < target:
+                left = mid + 1
+            else:
+                right = mid - 1
+        return left
+
+
+if __name__ == '__main__':
+    result = Solution().searchInsert([1, 3, 5, 6], 4)
+    print(result)

01-数组/day01/problem_solving_05.py

+"""
+加一
+"""
+from typing import List
+
+
+class Solution:
+    def plusOne(self, digits: List[int]) -> List[int]:
+        """
+        加一
+        :param digits:
+        :return:
+        """
+        if not digits:
+            return None
+        s = ''
+        res = []
+        for value in digits:
+            s = s + str(value)
+        for i in str(int(s) + 1):
+            res.append(int(i))
+        return res
+
+    def plusOne2(self, digits: List[int]) -> List[int]:
+        """
+        解法一的一行写法
+        :param digits:
+        :return:
+        """
+        return [int(i) for i in str(int(''.join([str(j) for j in digits])) + 1)]
+
+    def plusOne3(self, digits: List[int]) -> List[int]:
+        """
+        常规解法
+        :param digits:
+        :return:
+        """
+        plus = 1
+        for i in range(len(digits) - 1, -1, -1):
+            if digits[i] + plus == 10:
+                digits[i] = 0
+                plus = 1
+            else:
+                digits[i] += plus
+                plus = 0
+        if plus == 1:
+            digits.insert(0, 1)
+        return digits
+
+
+if __name__ == '__main__':
+    result = Solution().plusOne3([1, 2, 3])
+    print(result)

01-数组/day01/problem_solving_06.py

+"""
+合并两个有序数组
+"""
+from typing import List
+
+
+class Solution:
+    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
+        """
+        Do not return anything, modify nums1 in-place instead.
+        先填充后面的,再填充前面的
+        """
+        if not nums2:
+            return
+        len1 = m - 1
+        len2 = n - 1
+        k = m + n - 1
+        while len1 >= 0 and len2 >= 0:
+            if nums1[len1] > nums2[len2]:
+                nums1[k] = nums1[len1]
+                len1 -= 1
+            else:
+                nums1[k] = nums2[len2]
+                len2 -= 1
+            k -= 1
+
+        if len2 >= 0:
+            # 切片赋值,切片是不包含尾部的
+            nums1[:len2 + 1] = nums2[:len2 + 1]
+        return nums1
+
+
+if __name__ == '__main__':
+    Solution().merge([1, 2, 3, 0, 0, 0], 3, [2, 5, 6], 3)

01-数组/day01/problem_solving_07.py

+"""
+将有序数组转换为二叉搜索树
+"""
+
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+from typing import List, Optional
+
+
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+
+class Solution:
+    def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
+        if not nums:
+            return None
+        mid = (len(nums)) // 2
+        root = TreeNode(nums[mid])
+        root.left = self.sortedArrayToBST(nums[:mid])
+        root.right = self.sortedArrayToBST(nums[mid + 1:])
+        return root
+
+
+if __name__ == '__main__':
+    nums = [-10, -3, 0, 5, 9]
+    root = Solution().sortedArrayToBST(nums)
+    print(root)

01-数组/day01/problem_solving_08.py

+"""
+杨辉三角
+"""
+from typing import List
+
+
+class Solution:
+    def generate(self, numRows: int) -> List[List[int]]:
+        """
+        杨辉三角
+        第一行只有一个元素 1；
+        第 i 行有 i 个元素；
+        每一行的第一个和最后一个元素都为 1；
+        每个元素等于上一行中与其相邻的两个元素之和。
+        :param numRows:
+        :return:
+        """
+        if numRows == 0:
+            return []
+        result = [[1]]
+        for i in range(1, numRows):
+            # 当前行全为1
+            row = [1] * (i + 1)
+            # 只需要修改第二个和倒数第二个的值
+            for j in range(1, i):
+                # 值为上一行的左右2数相加
+                row[j] = result[i - 1][j - 1] + result[i - 1][j]
+            result.append(row)
+        return result
+
+
+if __name__ == '__main__':
+    root = Solution().generate(1)
+    print(root)

01-数组/day01/problem_solving_09.py

+"""
+杨辉三角 II
+"""
+from typing import List
+
+
+class Solution:
+    def getRow(self, rowIndex: int) -> List[int]:
+        """
+        索引从index=0开始
+        :param rowIndex:
+        :return:
+        """
+        if rowIndex == 0:
+            return [1]
+        result = [[1]]
+        # range(1,1)不走遍历,所以要加1
+        for i in range(1, rowIndex + 1):
+            row = [1] * (i + 1)
+            for j in range(1, i):
+                row[j] = result[i - 1][j - 1] + result[i - 1][j]
+            # 外层等于rowIndex即可结束遍历
+            if i == rowIndex:
+                return row
+            result.append(row)
+
+
+if __name__ == '__main__':
+    root = Solution().getRow(4)
+    print(root)

01-数组/day01/problem_solving_10.py

+"""
+买卖股票的最佳时机
+"""
+from typing import List
+
+
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        """
+        贪心算法
+        2个变量,一个最小价格,一个最大利润
+        :param prices:
+        :return:
+        """
+        min_price = prices[0]
+        max_profit = 0
+        for i in range(1, len(prices)):
+            if prices[i] < min_price:
+                min_price = prices[i]
+            else:
+                max_profit = max(max_profit, prices[i] - min_price)
+        return max_profit
+
+
+if __name__ == '__main__':
+    root = Solution().maxProfit([7, 1, 5, 3, 6, 4])
+    print(root)

01-数组/day02/problem_solving_11.py

+"""
+只出现一次的数字
+"""
+from typing import List
+
+
+class Solution:
+    def singleNumber(self, nums: List[int]) -> int:
+        """
+        异或运算
+        :param nums:
+        :return:
+        """
+        result = 0
+        for i in nums:
+            result ^= i
+        return result
+
+
+if __name__ == '__main__':
+    root = Solution().singleNumber([2, 2, 1, 1, 3])
+    print(root)

01-数组/day02/problem_solving_12.py

+"""
+多数元素
+"""
+from typing import List
+
+
+class Solution:
+    def majorityElement(self, nums: List[int]) -> int:
+        """
+        多数元素
+        :param nums:
+        :return:
+        """
+        count = 0
+        candidate = None
+        for i in nums:
+            if count == 0:
+                candidate = i
+            if i == candidate:
+                count += 1
+            else:
+                count += -1
+        return candidate
+
+    def majorityElement2(self, nums: List[int]) -> int:
+        """
+        多数元素
+        :param nums:
+        :return:
+        """
+        count = 0
+        candidate = None
+        for i in nums:
+            if count == 0:
+                candidate = i
+            count += (1 if i == candidate else -1)
+        return candidate
+
+
+if __name__ == '__main__':
+    root = Solution().majorityElement2([3, 2, 3])
+    print(root)

01-数组/day02/problem_solving_13.py

+"""
+存在重复元素
+"""
+from typing import List
+
+
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        """
+        set集合去重
+        :param nums:
+        :return:
+        """
+        new_list = set(nums)
+        return len(new_list) != len(nums)
+
+
+if __name__ == '__main__':
+    root = Solution().containsDuplicate([1, 2, 3, 1])
+    print(root)

01-数组/day02/problem_solving_14.py

+"""
+存在重复元素 II
+"""
+from typing import List
+
+
+class Solution:
+    def containsNearbyDuplicate(self, nums: List[int], k: int) -> bool:
+        """
+        基础暴力破解,超出时间限制
+        :param nums:
+        :param k:
+        :return:
+        """
+        for i, i_val in enumerate(nums):
+            for j, j_val in enumerate(nums):
+                if i != j and i_val == j_val and abs(i - j) <= k:
+                    return True
+        return False
+
+    def containsNearbyDuplicate1(self, nums: List[int], k: int) -> bool:
+        """
+        字典的使用
+        :param nums:
+        :param k:
+        :return:
+        """
+        num_dict = {}
+        for i, num in enumerate(nums):
+            # 关键判断
+            if num in num_dict and i - num_dict.get(num) <= k:
+                return True
+            else:
+                num_dict[num] = i
+        return False
+
+
+if __name__ == '__main__':
+    root = Solution().containsNearbyDuplicate1([1, 2, 3, 1], 3)
+    print(root)

01-数组/day02/problem_solving_15.py

+"""
+汇总区间
+"""
+from typing import List
+
+
+def getRange(start, end):
+    if start == end:
+        return str(start)
+    else:
+        return str(start) + '->' + str(end)
+
+class Solution:
+    def summaryRanges(self, nums: List[int]) -> List[str]:
+        """
+        数组变量,差值不为1,则特殊处理
+        :param nums:
+        :return:
+        """
+        if not nums:
+            return []
+        result = []
+        start = nums[0]
+        for i in range(1, len(nums)):
+            if nums[i] != nums[i - 1] + 1:
+                result.append(getRange(start, nums[i - 1]))
+                start = nums[i]
+        result.append(getRange(start, nums[-1]))
+        return result
+
+
+if __name__ == '__main__':
+    root = Solution().summaryRanges([0, 1, 2, 4, 5, 7])
+    print(root)

01-数组/day02/problem_solving_16.py

+"""
+丢失的数字
+"""
+from typing import List
+
+
+class Solution:
+    def missingNumber(self, nums: List[int]) -> int:
+        nums.sort()
+        if nums[0] != 0:
+            return 0
+        for i in range(1, len(nums)):
+            if nums[i] - nums[i - 1] > 1:
+                return nums[i] - 1
+        return nums[-1] + 1
+
+    def missingNumber2(self, nums: List[int]) -> int:
+        """
+        主技巧  数学相关,求0到n的和
+        :param nums:
+        :return:
+        """
+        total = len(nums) * (len(nums) + 1) / 2
+        sum_num = sum(nums)
+        return int(total - sum_num)
+
+
+if __name__ == '__main__':
+    # root = Solution().missingNumber([3, 0, 1])
+    # root = Solution().missingNumber([0, 1])
+    root = Solution().missingNumber2([9, 6, 4, 2, 3, 5, 7, 0, 1])
+    print(root)

01-数组/day02/problem_solving_17.py

+"""
+移动零
+"""
+from typing import List
+
+
+class Solution:
+    def moveZeroes(self, nums: List[int]) -> None:
+        """
+        Do not return anything, modify nums in-place instead.
+        """
+        i = 0
+        j = 0
+        while j < len(nums):
+            if nums[j] != 0:
+                nums[i] = nums[j]
+                i += 1
+            j += 1
+        for index in range(i, len(nums)):
+            nums[index] = 0
+        print(nums)
+
+
+if __name__ == '__main__':
+    Solution().moveZeroes([0, 1, 0, 3, 12])

01-数组/day02/problem_solving_18_01.py

+"""
+区域和检索 - 数组不可变
+"""
+from typing import List
+
+
+class NumArray:
+
+    def __init__(self, nums: List[int]):
+        self.nums = nums
+
+    def sumRange(self, left: int, right: int) -> int:
+        """
+        切片  求和
+        :param left:
+        :param right:
+        :return:
+        """
+        return sum(self.nums[left: right + 1])
+
+
+# Your NumArray object will be instantiated and called as such:
+# obj = NumArray(nums)
+# param_1 = obj.sumRange(left,right)
+if __name__ == '__main__':
+    result = NumArray([-2, 0, 3, -5, 2, -1]).sumRange(0, 2)
+    print(result)

01-数组/day02/problem_solving_18_02.py

+"""
+区域和检索 - 数组不可变
+"""
+from typing import List
+
+
+class NumArray:
+
+    def __init__(self, nums: List[int]):
+        self.nums = nums
+        for i in range(1, len(nums)):
+            # 前缀和
+            self.nums[i] += self.nums[i - 1]
+
+    def sumRange(self, left: int, right: int) -> int:
+        """
+        切片  求和
+        :param left:
+        :param right:
+        :return:
+        """
+        if left == 0:
+            return self.nums[right]
+        return self.nums[right] - self.nums[left - 1]
+
+
+# Your NumArray object will be instantiated and called as such:
+# obj = NumArray(nums)
+# param_1 = obj.sumRange(left,right)
+if __name__ == '__main__':
+    result = NumArray([-2, 0, 3, -5, 2, -1]).sumRange(0, 2)
+    print(result)

01-数组/day02/problem_solving_19_01.py

+"""
+两个数组的交集
+给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。
+"""
+from typing import List
+
+
+class Solution:
+    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
+        return list(set(nums1).intersection(nums2))
+
+
+if __name__ == '__main__':
+    result = Solution().intersection([1, 2, 2, 1], [2, 2])
+    print(result)

01-数组/day02/problem_solving_19_02.py

+"""
+两个数组的交集
+给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。
+"""
+from typing import List
+
+
+class Solution:
+    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
+        list1 = set(nums1)
+        list2 = set(nums2)
+        return list(list1 & list2)
+
+
+if __name__ == '__main__':
+    result = Solution().intersection([1, 2, 2, 1], [2, 2])
+    print(result)

01-数组/day02/problem_solving_19_03.py

+"""
+两个数组的交集
+给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。
+"""
+from typing import List
+
+
+class Solution:
+    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
+        result = []
+        for i in nums1:
+            if i in nums2 and i not in result:
+                result.append(i)
+        return result
+
+
+if __name__ == '__main__':
+    result = Solution().intersection([1, 2, 2, 1], [2, 2])
+    print(result)

01-数组/day02/problem_solving_20.py

+"""
+两个数组的交集 II
+"""
+from typing import List
+
+
+class Solution:
+    def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
+        dict1 = {}
+        # 统计nums1中的各个数字个数
+        for i in nums1:
+            if i in dict1:
+                dict1[i] += 1
+            else:
+                dict1[i] = 1
+        res = []
+        for num in nums2:
+            if num in dict1 and dict1[num] > 0:
+                res.append(num)
+                dict1[num] -= 1
+        return res
+
+
+if __name__ == '__main__':
+    result = Solution().intersect([1, 2, 2, 1], [2, 2])
+    print(result)

01-数组/day03/problem_solving_21.py

+"""
+第三大的数
+"""
+from typing import List
+
+
+class Solution:
+    def thirdMax(self, nums: List[int]) -> int:
+        if not nums:
+            return None
+        if len(nums) < 3:
+            return max(nums)
+        nums = sorted(set(nums), reverse=True)
+        if len(nums) >= 3:
+            return nums[2]
+        else:
+            return max(nums)
+
+
+if __name__ == '__main__':
+    result = Solution().thirdMax([3, 2, 1])
+    print(result)

01-数组/day03/problem_solving_22.py

+"""
+找到所有数组中消失的数字
+"""
+from typing import List
+
+
+class Solution:
+    def findDisappearedNumbers(self, nums: List[int]) -> List[int]:
+        all = set([i + 1 for i in range(len(nums))])
+        return list(all.difference(set(nums)))
+
+
+if __name__ == '__main__':
+    result = Solution().findDisappearedNumbers([4, 3, 2, 7, 8, 2, 3, 1])
+    print(result)

01-数组/day03/problem_solving_23.py

+"""
+分发饼干
+"""
+from typing import List
+
+
+class Solution:
+    def findContentChildren(self, g: List[int], s: List[int]) -> int:
+        g.sort()
+        s.sort()
+        i = 0
+        j = 0
+        count = 0
+        while i < len(g) and j < len(s):
+            if g[i] <= s[j]:
+                count += 1
+                i += 1
+            j += 1
+        return count
+
+
+if __name__ == '__main__':
+    result = Solution().findContentChildren([1, 2, 3], [1, 1])
+    print(result)

01-数组/day03/problem_solving_24.py

+"""
+岛屿的周长
+"""
+from typing import List
+
+
+class Solution:
+    def islandPerimeter(self, grid: List[List[int]]) -> int:
+        # x轴和y轴
+        directions = [[0, 1], [0, -1], [1, 0], [-1, 0]]
+        result = 0
+        for i in range(len(grid)):
+            for j in range(len(grid[0])):
+                # 如果是水域直接跳过,只处理岛屿的格子
+                if grid[i][j] == 1:
+                    # 存在岛屿则重置
+                    count = 0
+                    # 计算每个岛屿右左上下是否有水域或者是边界
+                    for x, y in directions:
+                        ix = i + x
+                        jy = j + y
+                        # 和岛屿连接的水域边,针对的是当前行的加减,当前行的坐标小于0或者大于等于最大index则说明是在边界
+                        if ix < 0 or ix >= len(grid) or jy < 0 or jy >= len(grid[0]) or grid[ix][jy] == 0:
+                            count += 1
+                    result += count
+        return result
+
+
+if __name__ == '__main__':
+    result = Solution().islandPerimeter([[0, 1, 0, 0], [1, 1, 1, 0], [0, 1, 0, 0], [1, 1, 0, 0]])
+    print(result)

01-数组/day03/problem_solving_25.py

+"""
+最大连续 1 的个数
+"""
+from typing import List
+
+
+class Solution:
+    def findMaxConsecutiveOnes(self, nums: List[int]) -> int:
+        """
+        试试贪心算法
+        :param nums:
+        :return:
+        """
+        res = 0
+        count = 0
+        for num in nums:
+            if num == 0:
+                count = 0
+                continue
+            count += 1
+            res = max(res, count)
+        return res
+
+
+if __name__ == '__main__':
+    result = Solution().findMaxConsecutiveOnes([1, 1, 0, 1, 1, 1])
+    print(result)

01-数组/day03/problem_solving_26.py

+"""
+提莫攻击
+"""
+from typing import List
+
+
+class Solution:
+    def findPoisonedDuration(self, timeSeries: List[int], duration: int) -> int:
+        """
+        贪心算法
+        :param timeSeries:
+        :param duration:
+        :return:
+        """
+        if not timeSeries:
+            return 0
+        res = duration
+        for i in range(1, len(timeSeries)):
+            # 中毒时间取最小值,当有重叠时timeSeries[i] - timeSeries[i - 1]
+            res += min(duration, timeSeries[i] - timeSeries[i - 1])
+        return res
+
+
+if __name__ == '__main__':
+    # result = Solution().findPoisonedDuration([1, 4], 2)
+    result = Solution().findPoisonedDuration([1, 2], 2)  # 输出3
+    print(result)

01-数组/day03/problem_solving_27_01.py

+"""
+下一个更大元素 I
+"""
+from typing import List
+
+
+class Solution:
+    def nextGreaterElement(self, nums1: List[int], nums2: List[int]) -> List[int]:
+        res = []
+        for num in nums1:
+            for index, num2 in enumerate(nums2):
+                if num == num2:
+                    flag = False
+                    for right in range(index + 1, len(nums2)):
+                        if right == len(nums2):
+                            break
+                        if nums2[right] > num2:
+                            res.append(nums2[right])
+                            flag = True
+                            break
+                    if flag:
+                        break
+                    res.append(-1)
+        return res
+
+
+if __name__ == '__main__':
+    result = Solution().nextGreaterElement([4, 1, 2], [1, 3, 4, 2])
+    print(result)

01-数组/day03/problem_solving_27_02.py

+"""
+下一个更大元素 I
+"""
+from typing import List
+
+
+class Solution:
+    def nextGreaterElement(self, nums1: List[int], nums2: List[int]) -> List[int]:
+        """
+        使用栈解决
+        栈顶元素肯定是比当前元素大的元素,否则取出,stack=[4,3,1] 2在遍历4的时候取出了
+        :param nums1:
+        :param nums2:
+        :return:
+        """
+        stack = []
+        next_map = {}
+        res = []
+
+        # 倒序遍历nums2
+        for num in nums2[::-1]:
+            while stack and stack[-1] < num:
+                stack.pop()
+            next_map[num] = stack[-1] if stack else -1
+            stack.append(num)
+        for num in nums1:
+            res.append(next_map[num])
+        return res
+
+
+if __name__ == '__main__':
+    result = Solution().nextGreaterElement([4, 1, 2], [1, 3, 4, 2])
+    print(result)

01-数组/day03/problem_solving_28.py

+"""
+键盘行
+"""
+from typing import List
+
+
+class Solution:
+    def findWords(self, words: List[str]) -> List[str]:
+        # 定义行字典,同一行的结果相同
+        keyboard = {
+            'q': 1, 'w': 1, 'e': 1, 'r': 1, 't': 1, 'y': 1, 'u': 1, 'i': 1, 'o': 1, 'p': 1,
+            'a': 2, 's': 2, 'd': 2, 'f': 2, 'g': 2, 'h': 2, 'j': 2, 'k': 2, 'l': 2,
+            'z': 3, 'x': 3, 'c': 3, 'v': 3, 'b': 3, 'n': 3, 'm': 3
+        }
+        res = []
+        for word in words:
+            # all表示每一项都满足条件
+            if all(keyboard[word[0].lower()] == keyboard[char.lower()] for char in word):
+                res.append(word)
+        return res
+
+
+if __name__ == '__main__':
+    result = Solution().findWords(['Hello', 'Alaska', 'Dad', 'Peace'])
+    print(result)

01-数组/day03/problem_solving_29.py

+"""
+相对名次
+"""
+from typing import List
+
+
+class Solution:
+    def findRelativeRanks(self, score: List[int]) -> List[str]:
+        """
+        列表排序,并倒序,使用字典存储起来,再一个一个的去找
+        :param score:
+        :return:
+        """
+        res = []
+        dict1 = {}
+        new_nums = sorted(score, reverse=True)
+        for index, num in enumerate(new_nums):
+            dict1[num] = index + 1
+        for s in score:
+            if dict1[s] == 1:
+                res.append('Gold Medal')
+            elif dict1[s] == 2:
+                res.append('Silver Medal')
+            elif dict1[s] == 3:
+                res.append('Bronze Medal')
+            else:
+                res.append(str(dict1[s]))
+        return res
+
+
+if __name__ == '__main__':
+    result = Solution().findRelativeRanks([5, 4, 3, 2, 1])
+    print(result)

01-数组/day03/problem_solving_30.py

+"""
+数组拆分
+"""
+from typing import List
+
+
+class Solution:
+    def arrayPairSum(self, nums: List[int]) -> int:
+        sum = 0
+        nums.sort()
+        for i in range(0, len(nums), 2):
+            sum += nums[i]
+        return sum
+
+
+if __name__ == '__main__':
+    result = Solution().arrayPairSum([1, 4, 3, 2])
+    print(result)

02-链表/problem_solving_01.py

+"""
+两数相加
+"""
+from typing import List, Optional
+
+
+class ListNode:
+    def __init__(self, val=0, next=None):
+        self.val = val
+        self.next = next
+
+
+class Solution:
+    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
+        """
+        链表遍历
+        :param l1:
+        :param l2:
+        :return:
+        """
+        res = ListNode(0)
+        cur = res
+        carry = 0
+        while l1 or l2:
+            x = l1.val if l1 else 0
+            y = l2.val if l2 else 0
+            s = x + y + carry
+            carry = s // 10
+            cur.next = ListNode(s % 10)
+            cur = cur.next
+            if l1:
+                l1 = l1.next
+            if l2:
+                l2 = l2.next
+        if carry:
+            cur.next = ListNode(carry)
+        return res.next
+
+
+if __name__ == '__main__':
+    l1 = ListNode(9)
+    l1.next = ListNode(9)
+    l1.next.next = ListNode(9)
+    l1.next.next.next = ListNode(9)
+    l1.next.next.next.next = ListNode(9)
+    l1.next.next.next.next.next = ListNode(9)
+    l1.next.next.next.next.next.next = ListNode(9)
+
+    l2 = ListNode(9)
+    l2.next = ListNode(9)
+    l2.next.next = ListNode(9)
+    l2.next.next.next = ListNode(9)
+    result = Solution().addTwoNumbers(l1, l2)
+    while result:
+        print(result.val, end=' -> ')
+        result = result.next

04-矩阵/problem_solving_01.py

+"""
+重构 2 行二进制矩阵
+"""
+from typing import List
+
+
+class Solution:
+    def reconstructMatrix(self, upper: int, lower: int, colsum: List[int]) -> List[List[int]]:
+        # 初始化结果集
+        n = len(colsum)
+        res = [[0] * n for _ in range(2)]
+        for i in range(n):
+            if colsum[i] == 2:
+                res[0][i] = 1
+                res[1][i] = 1
+                upper -= 1
+                lower -= 1
+            elif colsum[i] == 0:
+                res[0][i] = 0
+                res[1][i] = 0
+            else:
+                if upper > lower:
+                    res[0][i] = 1
+                    res[1][i] = 0
+                    upper -= 1
+                else:
+                    res[0][i] = 0
+                    res[1][i] = 1
+                    lower -= 1
+        if upper != 0 or lower != 0:
+            return []
+        return res
+
+
+if __name__ == '__main__':
+    # result = Solution().reconstructMatrix(2, 1, [1, 1, 1])
+    result = Solution().reconstructMatrix(5, 5, [2, 1, 2, 0, 1, 0, 1, 2, 0, 1])
+    print(result)

main.py

+# This is a sample Python script.
+
+# Press ⌃R to execute it or replace it with your code.
+# Press Double ⇧ to search everywhere for classes, files, tool windows, actions, and settings.
+
+
+def print_hi(name):
+    # Use a breakpoint in the code line below to debug your script.
+    print(f'Hi, {name}')  # Press ⌘F8 to toggle the breakpoint.
+
+
+# Press the green button in the gutter to run the script.
+if __name__ == '__main__':
+    print_hi('PyCharm')
+
+# See PyCharm help at https://www.jetbrains.com/help/pycharm/