D. J.:

- Added the leetcode problem and solution for 70, 139, 198, 300 and 322

Author: nobodyPerfecZ

README.md

@@ -15,7 +15,7 @@
             <img src="https://img.shields.io/badge/tests-passed-brightgreen">
         </a>
         <a>
-            <img src="https://img.shields.io/badge/coverage-97%25-brightgreen">
+            <img src="https://img.shields.io/badge/coverage-98%25-brightgreen">
         </a>
     </h1>
 </div>
@@ -70,6 +70,7 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [67 Add Binary](https://leetcode.com/problems/add-binary/description/)
 - [68 Text Justification](https://leetcode.com/problems/text-justification/description/)
 - [69 Sqrt(x)](https://leetcode.com/problems/sqrtx/description/)
+- [70 Climbing Stairs](https://leetcode.com/problems/climbing-stairs/description/)
 - [71 Simplify Path](https://leetcode.com/problems/simplify-path/description/)
 - [73 Set Matrix Zeroes](https://leetcode.com/problems/set-matrix-zeroes/description/)
 - [74 Search a 2D Matrix](https://leetcode.com/problems/search-a-2d-matrix/description/)
@@ -107,6 +108,7 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [136 Single Number](https://leetcode.com/problems/single-number/description/)
 - [137 Single Number II](https://leetcode.com/problems/single-number-ii/description/)
 - [138 Copy List with Random Pointer](https://leetcode.com/problems/copy-list-with-random-pointer/description/)
+- [139 Word Break](https://leetcode.com/problems/word-break/description/)
 - [141 Linked List Cycle](https://leetcode.com/problems/linked-list-cycle/description/)
 - [146 LRU Cache](https://leetcode.com/problems/lru-cache/description/)
 - [148 Sort List](https://leetcode.com/problems/sort-list/description/)
@@ -123,6 +125,7 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [189 Rotate Array](https://leetcode.com/problems/rotate-array/description/)
 - [190 Reverse Bits](https://leetcode.com/problems/reverse-bits/description/)
 - [191 Number of 1 Bits](https://leetcode.com/problems/number-of-1-bits/description/)
+- [198 House Robber](https://leetcode.com/problems/house-robber/description/)
 - [199 Binary Tree Right Side View](https://leetcode.com/problems/binary-tree-right-side-view/description/)
 - [200 Number of Islands](https://leetcode.com/problems/number-of-islands/description/)
 - [201 Bitwise AND of Numbers Range](https://leetcode.com/problems/bitwise-and-of-numbers-range/description/)
@@ -147,6 +150,8 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [274 H-Index](https://leetcode.com/problems/h-index/description/)
 - [289 Game of Life](https://leetcode.com/problems/game-of-life/description/)
 - [290 Word Pattern](https://leetcode.com/problems/word-pattern/description/)
+- [300 Longest Increasing Subsequence](https://leetcode.com/problems/longest-increasing-subsequence/description/)
+- [322 Coin Change](https://leetcode.com/problems/coin-change/description/)
 - [380 Insert Delete GetRandom O(1)](https://leetcode.com/problems/insert-delete-getrandom-o1/description/)
 - [383 Ransom Note](https://leetcode.com/problems/ransom-note/description/)
 - [392 Is Subsequence](https://leetcode.com/problems/is-subsequence/description/)

awesome_python_leetcode/_139_word_break.py

@@ -0,0 +1,24 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def wordBreak(self, s: str, wordDict: List[str]) -> bool:
+        """
+        Given a string s and a dictionary of strings wordDict, return true if s can be
+        segmented into a space-separated sequence of one or more dictionary words.
+
+        Note that the same word in the dictionary may be reused multiple times in the
+        segmentation.
+        """
+        dp = [False] * (len(s) + 1)
+        dp[len(s)] = True
+
+        for i in range(len(s) - 1, -1, -1):
+            for w in wordDict:
+                if (i + len(w)) <= len(s) and s[i : i + len(w)] == w:
+                    dp[i] = dp[i + len(w)]
+                if dp[i]:
+                    break
+        return dp[0]

awesome_python_leetcode/_198_house_robber.py

@@ -0,0 +1,24 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def rob(self, nums: List[int]) -> int:
+        """
+        You are a professional robber planning to rob houses along a street. Each house
+        has a certain amount of money stashed, the only constraint stopping you from
+        robbing each of them is that adjacent houses have security systems connected
+        and it will automatically contact the police if two adjacent houses were broken
+        into on the same night.
+
+        Given an integer array nums representing the amount of money of each house,
+        return the maximum amount of money you can rob tonight without alerting the
+        police.
+        """
+        second, first = 0, 0
+        for i in range(len(nums)):
+            tmp = max(nums[i] + second, first)
+            second = first
+            first = tmp
+        return first

awesome_python_leetcode/_300_longest_increasing_subsequence.py

@@ -0,0 +1,20 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def lengthOfLIS(self, nums: List[int]) -> int:
+        """
+        Given an integer array nums, return the length of the longest strictly
+        increasing subsequence.
+
+        A subsequence is an array that can be derived from another array by deleting
+        some or no elements without changing the order of the remaining elements.
+        """
+        dp = [1] * (len(nums))
+        for i in range(len(nums) - 2, -1, -1):
+            for j in range(i + 1, len(nums)):
+                if nums[i] < nums[j]:
+                    dp[i] = max(dp[i], 1 + dp[j])
+        return max(dp)

awesome_python_leetcode/_322_coin_change.py

@@ -0,0 +1,23 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def coinChange(self, coins: List[int], amount: int) -> int:
+        """
+        You are given an integer array coins representing coins of different
+        denominations and an integer amount representing a total amount of money.
+
+        Return the fewest number of coins that you need to make up that amount. If that
+        amount of money cannot be made up by any combination of the coins, return -1.
+
+        You may assume that you have an infinite number of each kind of coin.
+        """
+        dp = [amount + 1] * (amount + 1)
+        dp[0] = 0
+        for i in range(1, amount + 1):
+            for c in coins:
+                if i - c >= 0:
+                    dp[i] = min(dp[i], 1 + dp[i - c])
+        return dp[amount] if dp[amount] != amount + 1 else -1

awesome_python_leetcode/_70_climbing_stairs.py

@@ -0,0 +1,16 @@
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def climbStairs(self, n: int) -> int:
+        """
+        You are climbing a staircase. It takes n steps to reach the top.
+
+        Each time you can either climb 1 or 2 steps. In how many distinct ways can you
+        climb to the top?
+        """
+        one, two = 1, 1
+        for i in range(n - 1):
+            tmp = one
+            one = one + two
+            two = tmp
+        return one

tests/test_139_word_break.py

@@ -0,0 +1,19 @@
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._139_word_break import Solution
+
+
+@pytest.mark.parametrize(
+    argnames=["s", "wordDict", "expected"],
+    argvalues=[
+        ("leetcode", ["leet", "code"], True),
+        ("applepenapple", ["apple", "pen"], True),
+        ("catsandog", ["cats", "dog", "sand", "and", "cat"], False),
+    ],
+)
+def test_func(s: str, wordDict: List[str], expected: bool):
+    """Tests the solution of a LeetCode problem."""
+    breaked = Solution().wordBreak(s, wordDict)
+    assert breaked is expected

tests/test_198_house_robber.py

@@ -0,0 +1,19 @@
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._198_house_robber import Solution
+
+
+@pytest.mark.parametrize(
+    argnames=["nums", "expected"],
+    argvalues=[
+        ([1, 2, 3, 1], 4),
+        ([2, 7, 9, 3, 1], 12),
+        ([2, 1, 1, 2], 4),
+    ],
+)
+def test_func(nums: List[int], expected: int):
+    """Tests the solution of a LeetCode problem."""
+    value = Solution().rob(nums)
+    assert value == expected

tests/test_300_longest_increasing_subsequence.py

@@ -0,0 +1,19 @@
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._300_longest_increasing_subsequence import Solution
+
+
+@pytest.mark.parametrize(
+    argnames=["nums", "expected"],
+    argvalues=[
+        ([10, 9, 2, 5, 3, 7, 101, 18], 4),
+        ([0, 1, 0, 3, 2, 3], 4),
+        ([7, 7, 7, 7, 7, 7, 7], 1),
+    ],
+)
+def test_func(nums: List[int], expected: int):
+    """Tests the solution of a LeetCode problem."""
+    length = Solution().lengthOfLIS(nums)
+    assert length == expected

tests/test_322_coin_change.py

@@ -0,0 +1,19 @@
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._322_coin_change import Solution
+
+
+@pytest.mark.parametrize(
+    argnames=["coins", "amount", "expected"],
+    argvalues=[
+        ([1, 2, 5], 11, 3),
+        ([2], 3, -1),
+        ([1], 0, 0),
+    ],
+)
+def test_func(coins: List[int], amount: int, expected: int):
+    """Tests the solution of a LeetCode problem."""
+    num_coins = Solution().coinChange(coins, amount)
+    assert num_coins == expected