D. J.:

- Added the leetcode problem and solution for 474, 790 and 2140

Author: nobodyPerfecZ

README.md

@@ -211,6 +211,7 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [427 Construct Quad Tree](https://leetcode.com/problems/construct-quad-tree/description/)
 - [433 Minimum Genetic Mutation](https://leetcode.com/problems/minimum-genetic-mutation/description/)
 - [452 Minimum Number of Arrows to Burst Balloons](https://leetcode.com/problems/minimum-number-of-arrows-to-burst-balloons/description/)
+- [474 Ones and Zeroes](https://leetcode.com/problems/ones-and-zeroes/description/)
 - [502 IPO](https://leetcode.com/problems/ipo/description/)
 - [509 Fibonacci Number](https://leetcode.com/problems/fibonacci-number/description/)
 - [516 Longest Palindromic Subsequence](https://leetcode.com/problems/longest-palindromic-subsequence/description/)
@@ -221,6 +222,7 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [712 Minimum ASCII Delete Sum for Two Strings](https://leetcode.com/problems/minimum-ascii-delete-sum-for-two-strings/description/)
 - [740 Delete and Earn](https://leetcode.com/problems/delete-and-earn/description/)
 - [746 Min Cost Climbing Stairs](https://leetcode.com/problems/min-cost-climbing-stairs/description/)
+- [790 Domino and Tromino Tiling](https://leetcode.com/problems/domino-and-tromino-tiling/description/)
 - [909 Snakes and Ladders](https://leetcode.com/problems/snakes-and-ladders/description/)
 - [918 Maximum Sum Circular Subarray](https://leetcode.com/problems/maximum-sum-circular-subarray/description/)
 - [931 Minimum Falling Path Sum](https://leetcode.com/problems/minimum-falling-path-sum/description/)
@@ -229,6 +231,7 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [1143 Longest Common Subsequence](https://leetcode.com/problems/longest-common-subsequence/description/)
 - [1534 Count Good Triplets](https://leetcode.com/problems/count-good-triplets/description)
 - [1922 Count Good Numbers](https://leetcode.com/problems/count-good-numbers/description/)
+- [2140 Solving Questions With Brainpower](https://leetcode.com/problems/solving-questions-with-brainpower/description/)
 - [2466 Count Ways To Build Good Strings](https://leetcode.com/problems/count-ways-to-build-good-strings/description/)
 
 ## Development 🔧

awesome_python_leetcode/_2140_solving_questions_with_brainpower.py

@@ -0,0 +1,34 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def mostPoints(self, questions: List[List[int]]) -> int:
+        """
+        You are given a 0-indexed 2D integer array questions where
+        questions[i] = [pointsi, brainpoweri].
+
+        The array describes the questions of an exam, where you have to process the
+        questions in order (i.e., starting from question 0) and make a decision whether
+        to solve or skip each question. Solving question i will earn you pointsi points
+        but you will be unable to solve each of the next brainpoweri questions. If you
+        skip question i, you get to make the decision on the next question.
+
+        - For example, given questions = [[3, 2], [4, 3], [4, 4], [2, 5]]:
+            - If question 0 is solved, you will earn 3 points but you will be unable to
+            solve questions 1 and 2.
+            - If instead, question 0 is skipped and question 1 is solved, you will earn
+            4 points but you will be unable to solve questions 2 and 3.
+
+        Return the maximum points you can earn for the exam.
+        """
+        dp = [0 for _ in range(len(questions))]
+        dp[-1] = questions[-1][0]
+        for i in range(len(questions) - 2, -1, -1):
+            j = questions[i][1]
+            if i + j + 1 < len(questions):
+                dp[i] = max(questions[i][0] + dp[i + j + 1], dp[i + 1])
+            else:
+                dp[i] = max(questions[i][0], dp[i + 1])
+        return dp[0]

awesome_python_leetcode/_474_ones_and_zeroes.py

@@ -0,0 +1,34 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def findMaxForm(self, strs: List[str], m: int, n: int) -> int:
+        """
+        You are given an array of binary strings strs and two integers m and n.
+
+        Return the size of the largest subset of strs such that there are at most m 0's
+        and n 1's in the subset.
+
+        A set x is a subset of a set y if all elements of x are also elements of y.
+        """
+        dp = {}
+
+        def dfs(i: int, m: int, n: int):
+            if i == len(strs):
+                return 0
+            if (i, m, n) in dp:
+                return dp[(i, m, n)]
+
+            zeroes = strs[i].count("0")
+            ones = strs[i].count("1")
+            dp[(i, m, n)] = dfs(i + 1, m, n)
+            if zeroes <= m and ones <= n:
+                dp[(i, m, n)] = max(
+                    dp[(i, m, n)],
+                    1 + dfs(i + 1, m - zeroes, n - ones),
+                )
+            return dp[(i, m, n)]
+
+        return dfs(0, m, n)

awesome_python_leetcode/_790_domino_and_tromino_tiling.py

@@ -0,0 +1,25 @@
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def numTilings(self, n: int) -> int:
+        """
+        You have two types of tiles: a 2 x 1 domino shape and a tromino shape.
+        You may rotate these shapes.
+
+        Given an integer n, return the number of ways to tile an 2 x n board.
+        Since the answer may be very large, return it modulo 109 + 7.
+
+        In a tiling, every square must be covered by a tile.
+        Two tilings are different if and only if there are two 4-directionally adjacent
+        cells on the board such that exactly one of the tilings has both squares
+        occupied by a tile.
+        """
+        F = [0 for _ in range(n + 1)]
+        F[0], F[1] = 1, 1
+        T = [0 for _ in range(n + 1)]
+        B = [0 for _ in range(n + 1)]
+        for i in range(2, n + 1):
+            F[i] = F[i - 1] + F[i - 2] + T[i - 1] + B[i - 1]
+            T[i] = B[i - 1] + F[i - 2]
+            B[i] = T[i - 1] + F[i - 2]
+        return F[-1] % (10**9 + 7)

tests/test_2140_solving_questions_with_brainpower.py

@@ -0,0 +1,18 @@
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._2140_solving_questions_with_brainpower import Solution
+
+
+@pytest.mark.parametrize(
+    argnames=["questions", "expected"],
+    argvalues=[
+        ([[3, 2], [4, 3], [4, 4], [2, 5]], 5),
+        ([[1, 1], [2, 2], [3, 3], [4, 4], [5, 5]], 7),
+    ],
+)
+def test_func(questions: List[int], expected: int):
+    """Tests the solution of a LeetCode problem."""
+    max_points = Solution().mostPoints(questions)
+    assert max_points == expected

tests/test_474_ones_and_zeroes.py

@@ -0,0 +1,18 @@
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._474_ones_and_zeroes import Solution
+
+
+@pytest.mark.parametrize(
+    argnames=["strs", "m", "n", "expected"],
+    argvalues=[
+        (["10", "0001", "111001", "1", "0"], 5, 3, 4),
+        (["10", "0", "1"], 1, 1, 2),
+    ],
+)
+def test_func(strs: List[str], m: int, n: int, expected: int):
+    """Tests the solution of a LeetCode problem."""
+    max_subset = Solution().findMaxForm(strs, m, n)
+    assert max_subset == expected

tests/test_790_domino_and_tromino_tiling.py

@@ -0,0 +1,16 @@
+import pytest
+
+from awesome_python_leetcode._790_domino_and_tromino_tiling import Solution
+
+
+@pytest.mark.parametrize(
+    argnames=["n", "expected"],
+    argvalues=[
+        (3, 5),
+        (1, 1),
+    ],
+)
+def test_func(n: int, expected: int):
+    """Tests the solution of a LeetCode problem."""
+    two_sum = Solution().numTilings(n)
+    assert two_sum == expected