D. J.:

- Added the leetcode problem and solution for 118, 509, 740, 746, 931 and 1137

Author: nobodyPerfecZ

README.md

@@ -22,6 +22,41 @@
 
 This repository contains awesome LeetCode problems and solutions written in Python to prepare for coding interviews.
 
+## Leetcode Study Plans 📚
+
+### Introduction To
+
+- [Introduction to Pandas](https://leetcode.com/studyplan/introduction-to-pandas/)
+
+### 30 Days Challenge
+
+- [30 Days of Pandas](https://leetcode.com/studyplan/30-days-of-pandas/)
+- [30 Days of JavaScript](https://leetcode.com/studyplan/30-days-of-javascript/)
+
+### Cracking Coding Interview
+
+- [Top Interview 150](https://leetcode.com/studyplan/top-interview-150/)
+- [LeetCode 75](https://leetcode.com/studyplan/leetcode-75/)
+- [Top 100 Liked](https://leetcode.com/studyplan/top-100-liked/)
+- [SQL 50](https://leetcode.com/studyplan/top-sql-50/)
+- [Premium Algo 100](https://leetcode.com/studyplan/premium-algo-100/)
+- [Advanced SQL 50](https://leetcode.com/studyplan/premium-sql-50/)
+
+### Sprint Interview
+
+- [Amazon Spring '23 High Frequency](https://leetcode.com/studyplan/amazon-spring-23-high-frequency/)
+- [Google Spring '23 High Frequency](https://leetcode.com/studyplan/google-spring-23-high-frequency/)
+- [TikTok Spring '23 High Frequency](https://leetcode.com/studyplan/tiktok-spring-23-high-frequency/)
+- [Apple Spring '23 High Frequency](https://leetcode.com/studyplan/apple-spring-23-high-frequency/)
+
+### In-Depth Topics
+
+- [Programming Skills](https://leetcode.com/studyplan/programming-skills/)
+- [Dynamic Programming](https://leetcode.com/studyplan/dynamic-programming/)
+- [Dynamic Programming Grandmaster](https://leetcode.com/studyplan/dynamic-programming-grandmaster/)
+- [Graph Theory](https://leetcode.com/studyplan/graph-theory/)
+- [Binary Search](https://leetcode.com/studyplan/binary-search/)
+
 ## Leetcode Problems & Solutions 💻
 
 - [1 Two Sum](https://leetcode.com/problems/two-sum/description/)
@@ -99,6 +134,7 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [112 Path Sum](https://leetcode.com/problems/path-sum/description/)
 - [114 Flatten Binary Tree to Linked List](https://leetcode.com/problems/flatten-binary-tree-to-linked-list/description/)
 - [117 Populating Next Right Pointers in Each Node II](https://leetcode.com/problems/populating-next-right-pointers-in-each-node-ii/description/)
+- [118 Pascals Triangle](https://leetcode.com/problems/pascals-triangle/description/)
 - [120 Triangle](https://leetcode.com/problems/triangle/description/)
 - [121 Best Time to Buy and Sell Stock](https://leetcode.com/problems/best-time-to-buy-and-sell-stock/description/)
 - [122 Best Time to Buy and Sell Stock II](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/description/)
@@ -172,10 +208,15 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [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/)
 - [502 IPO](https://leetcode.com/problems/ipo/description/)
+- [509 Fibonacci Number](https://leetcode.com/problems/fibonacci-number/description/)
 - [530 Minimum Absolute Difference in BST](https://leetcode.com/problems/minimum-absolute-difference-in-bst/description/)
 - [637 Average of Levels in Binary Tree](https://leetcode.com/problems/average-of-levels-in-binary-tree/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/)
 - [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/)
+- [1137 N-th Tribonacci Number](https://leetcode.com/problems/n-th-tribonacci-number/description/)
 
 ## Development 🔧
 

awesome_python_leetcode/_1137_nth_tribonacci_number.py

@@ -0,0 +1,24 @@
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def tribonacci(self, n: int) -> int:
+        """
+        The Tribonacci sequence Tn is defined as follows:
+
+        T0 = 0, T1 = 1, T2 = 1, and Tn+3 = Tn + Tn+1 + Tn+2 for n >= 0.
+
+        Given n, return the value of Tn.
+        """
+        if n == 0:
+            return 0
+        elif n <= 2:
+            return 1
+
+        dp = [0 for _ in range(n + 1)]
+        dp[1] = 1
+        dp[2] = 1
+
+        for i in range(3, n + 1):
+            dp[i] = dp[i - 1] + dp[i - 2] + dp[i - 3]
+
+        return dp[-1]

awesome_python_leetcode/_118_pascals_triangle.py

@@ -0,0 +1,27 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def generate(self, numRows: int) -> List[List[int]]:
+        """
+        Given an integer numRows, return the first numRows of Pascal's triangle.
+
+        In Pascal's triangle, each number is the sum of the two numbers directly above
+        it as shown:
+        numRows = 5
+        Output = [
+            [1],
+            [1, 1],
+            [1, 2, 1],
+            [1, 3, 3, 1],
+            [1, 4, 6, 4, 1],
+            [1, 5, 10, 10, 5, 1],
+        ]
+        """
+        dp = [[1 for _ in range(i)] for i in range(1, numRows + 1)]
+        for i in range(2, numRows):
+            for j in range(1, len(dp[i]) - 1):
+                dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j]
+        return dp

awesome_python_leetcode/_509_fibonacci_number.py

@@ -0,0 +1,26 @@
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def fib(self, n: int) -> int:
+        """
+        The Fibonacci numbers, commonly denoted F(n) form a sequence, called the
+        Fibonacci sequence, such that each number is the sum of the two preceding ones,
+        starting from 0 and 1. That is,
+
+        F(0) = 0, F(1) = 1
+        F(n) = F(n - 1) + F(n - 2), for n > 1.
+
+        Given n, calculate F(n).
+        """
+        if n == 0:
+            return 0
+        elif n <= 1:
+            return 1
+
+        dp = [0 for _ in range(n + 1)]
+        dp[1] = 1
+
+        for i in range(2, n + 1):
+            dp[i] = dp[i - 1] + dp[i - 2]
+
+        return dp[-1]

awesome_python_leetcode/_740_delete_and_earn.py

@@ -0,0 +1,33 @@
+import collections
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def deleteAndEarn(self, nums: List[int]) -> int:
+        """
+        You are given an integer array nums. You want to maximize the number of points
+        you get by performing the following operation any number of times:
+        - Pick any nums[i] and delete it to earn nums[i] points. Afterwards, you must
+        delete every element equal to nums[i] - 1 and every element equal to
+        nums[i] + 1.
+
+        Return the maximum number of points you can earn by applying the above
+        operation some number of times.
+        """
+        if len(nums) == 1:
+            return nums[0]
+
+        count = collections.defaultdict(int)
+        minVal, maxVal = float("inf"), -float("inf")
+        for n in nums:
+            count[n] += n
+            minVal = min(minVal, n)
+            maxVal = max(maxVal, n)
+
+        dp = [0 for i in range(maxVal + 1)]
+        for i in range(minVal, maxVal + 1):
+            dp[i] = max(dp[i - 2] + count[i], dp[i - 1])
+
+        return max(dp[-1], dp[-2])

awesome_python_leetcode/_746_min_cost_climbing_stairs.py

@@ -0,0 +1,19 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def minCostClimbingStairs(self, cost: List[int]) -> int:
+        """
+        You are given an integer array cost where cost[i] is the cost of ith step on a
+        staircase. Once you pay the cost, you can either climb one or two steps.
+
+        You can either start from the step with index 0, or the step with index 1.
+
+        Return the minimum cost to reach the top of the floor.
+        """
+        dp = [0 for _ in range(len(cost))]
+        for i in range(len(cost)):
+            dp[i] = cost[i] + min(dp[i - 1], dp[i - 2])
+        return min(dp[-1], dp[-2])

awesome_python_leetcode/_931_minimum_falling_path_sum.py

@@ -0,0 +1,33 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def minFallingPathSum(self, matrix: List[List[int]]) -> int:
+        """
+        Given an n x n array of integers matrix, return the minimum sum of any falling
+        path through matrix.
+
+        A falling path starts at any element in the first row and chooses the element
+        in the next row that is either directly below or diagonally left/right.
+        Specifically, the next element from position (row, col) will be
+        (row + 1, col - 1), (row + 1, col), or (row + 1, col + 1).
+        """
+        dp = [
+            [matrix[i][j] if i == 0 else 0 for j in range(len(matrix[i]))]
+            for i in range(len(matrix))
+        ]
+
+        for i in range(1, len(matrix)):
+            for j in range(len(matrix[i])):
+                if j == 0:
+                    dp[i][j] = min(dp[i - 1][j], dp[i - 1][j + 1]) + matrix[i][j]
+                elif j == len(matrix[i]) - 1:
+                    dp[i][j] = min(dp[i - 1][j - 1], dp[i - 1][j]) + matrix[i][j]
+                else:
+                    dp[i][j] = (
+                        min(dp[i - 1][j - 1], dp[i - 1][j], dp[i - 1][j + 1])
+                        + matrix[i][j]
+                    )
+        return min(dp[-1])

tests/test_1137_nth_tribonacci_number.py

@@ -0,0 +1,16 @@
+import pytest
+
+from awesome_python_leetcode._1137_nth_tribonacci_number import Solution
+
+
+@pytest.mark.parametrize(
+    argnames=["n", "expected"],
+    argvalues=[
+        (4, 4),
+        (25, 1389537),
+    ],
+)
+def test_func(n: int, expected: int):
+    """Tests the solution of a LeetCode problem."""
+    tn = Solution().tribonacci(n)
+    assert tn == expected

tests/test_118_pascals_triangle.py

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

tests/test_509_fibonacci_number.py

@@ -0,0 +1,17 @@
+import pytest
+
+from awesome_python_leetcode._509_fibonacci_number import Solution
+
+
+@pytest.mark.parametrize(
+    argnames=["n", "expected"],
+    argvalues=[
+        (2, 1),
+        (3, 2),
+        (4, 3),
+    ],
+)
+def test_func(n: int, expected: int):
+    """Tests the solution of a LeetCode problem."""
+    fn = Solution().fib(n)
+    assert fn == expected

tests/test_740_delete_and_earn.py

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

tests/test_746_min_cost_climbing_stairs.py

@@ -0,0 +1,18 @@
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._746_min_cost_climbing_stairs import Solution
+
+
+@pytest.mark.parametrize(
+    argnames=["cost", "expected"],
+    argvalues=[
+        ([10, 15, 20], 15),
+        ([1, 100, 1, 1, 1, 100, 1, 1, 100, 1], 6),
+    ],
+)
+def test_func(cost: List[int], expected: int):
+    """Tests the solution of a LeetCode problem."""
+    min_cost = Solution().minCostClimbingStairs(cost)
+    assert min_cost == expected

tests/test_931_minimum_falling_path_sum.py

@@ -0,0 +1,18 @@
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._931_minimum_falling_path_sum import Solution
+
+
+@pytest.mark.parametrize(
+    argnames=["matrix", "expected"],
+    argvalues=[
+        ([[2, 1, 3], [6, 5, 4], [7, 8, 9]], 13),
+        ([[-19, 57], [-40, -5]], -59),
+    ],
+)
+def test_func(matrix: List[List[int]], expected: int):
+    """Tests the solution of a LeetCode problem."""
+    falling_sum = Solution().minFallingPathSum(matrix)
+    assert falling_sum == expected