Added tasks 120-127

Author: ThanhNIT

src/main/python/g0101_0200/s0120_triangle/Solution0120.py

@@ -0,0 +1,18 @@
+# #Medium #Array #Dynamic_Programming #Algorithm_I_Day_12_Dynamic_Programming
+# #Dynamic_Programming_I_Day_13 #Udemy_Dynamic_Programming #Top_Interview_150_Multidimensional_DP
+# #2025_09_14_Time_0_ms_(100.00%)_Space_18.71_MB_(81.95%)
+
+from typing import List
+
+class Solution:
+    def minimumTotal(self, triangle: List[List[int]]) -> int:
+        # create a 1D array, copy last elements
+        # iterate reverse last - 1
+        n = len(triangle)
+        dp = []
+        for num in triangle[-1]:
+            dp.append(num)
+        for i in range(n-2, -1, -1):
+            for j in range(i+1):
+                dp[j] = triangle[i][j] + min(dp[j], dp[j+1])
+        return dp[0]

src/main/python/g0101_0200/s0120_triangle/Solution0120_test.py

@@ -0,0 +1,11 @@
+import unittest
+from Solution0120 import Solution
+
+class SolutionTest(unittest.TestCase):
+    def test_minimumTotal(self):
+        triangle = [[2], [3, 4], [6, 5, 7], [4, 1, 8, 3]]
+        self.assertEqual(Solution().minimumTotal(triangle), 11)
+
+    def test_minimumTotal2(self):
+        triangle = [[-10]]
+        self.assertEqual(Solution().minimumTotal(triangle), -10)

src/main/python/g0101_0200/s0120_triangle/readme.md

@@ -0,0 +1,37 @@
+120\. Triangle
+
+Medium
+
+Given a `triangle` array, return _the minimum path sum from top to bottom_.
+
+For each step, you may move to an adjacent number of the row below. More formally, if you are on index `i` on the current row, you may move to either index `i` or index `i + 1` on the next row.
+
+**Example 1:**
+
+**Input:** triangle = [[2],[3,4],[6,5,7],[4,1,8,3]]
+
+**Output:** 11
+
+**Explanation:**
+
+    The triangle looks like:
+        2
+       3 4
+      6 5 7
+     4 1 8 3
+     The minimum path sum from top to bottom is 2 + 3 + 5 + 1 = 11 (underlined above). 
+
+**Example 2:**
+
+**Input:** triangle = [[-10]]
+
+**Output:** -10 
+
+**Constraints:**
+
+*   `1 <= triangle.length <= 200`
+*   `triangle[0].length == 1`
+*   `triangle[i].length == triangle[i - 1].length + 1`
+*   <code>-10<sup>4</sup> <= triangle[i][j] <= 10<sup>4</sup></code>
+
+**Follow up:** Could you do this using only `O(n)` extra space, where `n` is the total number of rows in the triangle?

src/main/python/g0101_0200/s0122_best_time_to_buy_and_sell_stock_ii/Solution0122.py

@@ -0,0 +1,13 @@
+# #Medium #Top_Interview_Questions #Array #Dynamic_Programming #Greedy #Dynamic_Programming_I_Day_7
+# #Udemy_Arrays #Top_Interview_150_Array/String
+# #2025_09_14_Time_0_ms_(100.00%)_Space_18.77_MB_(70.67%)
+
+from typing import List
+
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        max_profit = 0
+        for i in range(1, len(prices)):
+            if prices[i] > prices[i - 1]:
+                max_profit += prices[i] - prices[i - 1]
+        return max_profit

src/main/python/g0101_0200/s0122_best_time_to_buy_and_sell_stock_ii/Solution0122_test.py

@@ -0,0 +1,12 @@
+import unittest
+from Solution0122 import Solution
+
+class SolutionTest(unittest.TestCase):
+    def test_maxProfit(self):
+        self.assertEqual(Solution().maxProfit([7, 1, 5, 3, 6, 4]), 7)
+
+    def test_maxProfit2(self):
+        self.assertEqual(Solution().maxProfit([1, 2, 3, 4, 5]), 4)
+
+    def test_maxProfit3(self):
+        self.assertEqual(Solution().maxProfit([7, 6, 4, 3, 1]), 0)

src/main/python/g0101_0200/s0122_best_time_to_buy_and_sell_stock_ii/readme.md

@@ -0,0 +1,38 @@
+122\. Best Time to Buy and Sell Stock II
+
+Medium
+
+You are given an integer array `prices` where `prices[i]` is the price of a given stock on the `ith` day.
+
+On each day, you may decide to buy and/or sell the stock. You can only hold **at most one** share of the stock at any time. However, you can buy it then immediately sell it on the **same day**.
+
+Find and return _the **maximum** profit you can achieve_.
+
+**Example 1:**
+
+**Input:** prices = [7,1,5,3,6,4]
+
+**Output:** 7
+
+**Explanation:** Buy on day 2 (price = 1) and sell on day 3 (price = 5), profit = 5-1 = 4. Then buy on day 4 (price = 3) and sell on day 5 (price = 6), profit = 6-3 = 3. Total profit is 4 + 3 = 7. 
+
+**Example 2:**
+
+**Input:** prices = [1,2,3,4,5]
+
+**Output:** 4
+
+**Explanation:** Buy on day 1 (price = 1) and sell on day 5 (price = 5), profit = 5-1 = 4. Total profit is 4. 
+
+**Example 3:**
+
+**Input:** prices = [7,6,4,3,1]
+
+**Output:** 0
+
+**Explanation:** There is no way to make a positive profit, so we never buy the stock to achieve the maximum profit of 0. 
+
+**Constraints:**
+
+*   <code>1 <= prices.length <= 3 * 10<sup>4</sup></code>
+*   <code>0 <= prices[i] <= 10<sup>4</sup></code>

src/main/python/g0101_0200/s0123_best_time_to_buy_and_sell_stock_iii/Solution0123.py

@@ -0,0 +1,19 @@
+# #Hard #Array #Dynamic_Programming #Top_Interview_150_Multidimensional_DP
+# #2025_09_14_Time_232_ms_(75.22%)_Space_28.79_MB_(85.10%)
+
+from typing import List
+
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        if len(prices) == 0:
+            return 0
+        fb = float('-inf')  # first buy
+        sb = float('-inf')  # second buy
+        fs = 0  # first sell
+        ss = 0  # second sell
+        for price in prices:
+            fb = max(fb, -price)
+            fs = max(fs, fb + price)
+            sb = max(sb, fs - price)
+            ss = max(ss, sb + price)
+        return ss

src/main/python/g0101_0200/s0123_best_time_to_buy_and_sell_stock_iii/Solution0123_test.py

@@ -0,0 +1,12 @@
+import unittest
+from Solution0123 import Solution
+
+class SolutionTest(unittest.TestCase):
+    def test_maxProfit(self):
+        self.assertEqual(Solution().maxProfit([3, 3, 5, 0, 0, 3, 1, 4]), 6)
+
+    def test_maxProfit2(self):
+        self.assertEqual(Solution().maxProfit([1, 2, 3, 4, 5]), 4)
+
+    def test_maxProfit3(self):
+        self.assertEqual(Solution().maxProfit([7, 6, 4, 3, 1]), 0)

src/main/python/g0101_0200/s0123_best_time_to_buy_and_sell_stock_iii/readme.md

@@ -0,0 +1,44 @@
+123\. Best Time to Buy and Sell Stock III
+
+Hard
+
+You are given an array `prices` where `prices[i]` is the price of a given stock on the `ith` day.
+
+Find the maximum profit you can achieve. You may complete **at most two transactions**.
+
+**Note:** You may not engage in multiple transactions simultaneously (i.e., you must sell the stock before you buy again).
+
+**Example 1:**
+
+**Input:** prices = [3,3,5,0,0,3,1,4]
+
+**Output:** 6
+
+**Explanation:** Buy on day 4 (price = 0) and sell on day 6 (price = 3), profit = 3-0 = 3. Then buy on day 7 (price = 1) and sell on day 8 (price = 4), profit = 4-1 = 3.
+
+**Example 2:**
+
+**Input:** prices = [1,2,3,4,5]
+
+**Output:** 4
+
+**Explanation:** Buy on day 1 (price = 1) and sell on day 5 (price = 5), profit = 5-1 = 4. Note that you cannot buy on day 1, buy on day 2 and sell them later, as you are engaging multiple transactions at the same time. You must sell before buying again. 
+
+**Example 3:**
+
+**Input:** prices = [7,6,4,3,1]
+
+**Output:** 0
+
+**Explanation:** In this case, no transaction is done, i.e. max profit = 0. 
+
+**Example 4:**
+
+**Input:** prices = [1]
+
+**Output:** 0 
+
+**Constraints:**
+
+*   <code>1 <= prices.length <= 10<sup>5</sup></code>
+*   <code>0 <= prices[i] <= 10<sup>5</sup></code>

src/main/python/g0101_0200/s0125_valid_palindrome/Solution0125.py

@@ -0,0 +1,9 @@
+# #Hard #Array #Dynamic_Programming #Top_Interview_150_Multidimensional_DP
+# #2025_09_14_Time_232_ms_(75.22%)_Space_28.79_MB_(85.10%)
+
+import re
+
+class Solution:
+    def isPalindrome(self, s: str) -> bool:
+        cleaned = ''.join(re.findall('[A-Za-z0-9]+', s.lower()))
+        return cleaned == cleaned[::-1]