Added tasks 120-135

Author: ThanhNIT

README.md

@@ -0,0 +1,40 @@
+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: 
+    
+<ins>2</ins> 
+
+<ins>3</ins> 4 
+
+6 <ins>5</ins> 7 
+
+4 <ins>1</ins> 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/go/g0101_0200/s0120_triangle/readme.md

@@ -0,0 +1,38 @@
+package s0120_triangle
+
+// #Medium #Array #Dynamic_Programming #Algorithm_I_Day_12_Dynamic_Programming
+// #Dynamic_Programming_I_Day_13 #Udemy_Dynamic_Programming #Top_Interview_150_Multidimensional_DP
+// #2025_05_18_Time_0_ms_(100.00%)_Space_5.48_MB_(16.19%)
+
+func minimumTotal(triangle [][]int) int {
+	if len(triangle) == 0 {
+		return 0
+	}
+	dp := make([][]int, len(triangle))
+	for i := range dp {
+		dp[i] = make([]int, len(triangle[len(triangle)-1]))
+		for j := range dp[i] {
+			dp[i][j] = -10001
+		}
+	}
+	return dfs(triangle, dp, 0, 0)
+}
+
+func dfs(triangle [][]int, dp [][]int, row, col int) int {
+	if row >= len(triangle) {
+		return 0
+	}
+	if dp[row][col] != -10001 {
+		return dp[row][col]
+	}
+	sum := triangle[row][col] + min(dfs(triangle, dp, row+1, col), dfs(triangle, dp, row+1, col+1))
+	dp[row][col] = sum
+	return sum
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}

src/main/go/g0101_0200/s0120_triangle/solution.go

@@ -0,0 +1,28 @@
+package s0120_triangle
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestMinimumTotal(t *testing.T) {
+	triangle := [][]int{
+		{2},
+		{3, 4},
+		{6, 5, 7},
+		{4, 1, 8, 3},
+	}
+	assert.Equal(t, 11, minimumTotal(triangle))
+}
+
+func TestMinimumTotal2(t *testing.T) {
+	triangle := [][]int{
+		{-10},
+	}
+	assert.Equal(t, -10, minimumTotal(triangle))
+}
+
+func TestMinimumTotal3(t *testing.T) {
+	var triangle [][]int
+	assert.Equal(t, 0, minimumTotal(triangle))
+}

src/main/go/g0101_0200/s0120_triangle/solution_test.go

@@ -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 <code>i<sup>th</sup></code> 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/go/g0101_0200/s0122_best_time_to_buy_and_sell_stock_ii/readme.md

@@ -0,0 +1,15 @@
+package s0122_best_time_to_buy_and_sell_stock_ii
+
+// #Medium #Top_Interview_Questions #Array #Dynamic_Programming #Greedy #Dynamic_Programming_I_Day_7
+// #Udemy_Arrays #Top_Interview_150_Array/String
+// #2025_05_18_Time_0_ms_(100.00%)_Space_5.11_MB_(46.22%)
+
+func maxProfit(prices []int) int {
+	max := 0
+	for i := 1; i < len(prices); i++ {
+		if prices[i] > prices[i-1] {
+			max += prices[i] - prices[i-1]
+		}
+	}
+	return max
+}

src/main/go/g0101_0200/s0122_best_time_to_buy_and_sell_stock_ii/solution.go

@@ -0,0 +1,21 @@
+package s0122_best_time_to_buy_and_sell_stock_ii
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestMaxProfit(t *testing.T) {
+	prices := []int{7, 1, 5, 3, 6, 4}
+	assert.Equal(t, 7, maxProfit(prices))
+}
+
+func TestMaxProfit2(t *testing.T) {
+	prices := []int{1, 2, 3, 4, 5}
+	assert.Equal(t, 4, maxProfit(prices))
+}
+
+func TestMaxProfit3(t *testing.T) {
+	prices := []int{7, 6, 4, 3, 1}
+	assert.Equal(t, 0, maxProfit(prices))
+}

src/main/go/g0101_0200/s0122_best_time_to_buy_and_sell_stock_ii/solution_test.go

@@ -0,0 +1,38 @@
+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 <code>i<sup>th</sup></code> 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.
+
+**Constraints:**
+
+*   <code>1 <= prices.length <= 10<sup>5</sup></code>
+*   <code>0 <= prices[i] <= 10<sup>5</sup></code>

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

@@ -0,0 +1,28 @@
+package s0123_best_time_to_buy_and_sell_stock_iii
+
+// #Hard #Array #Dynamic_Programming #Top_Interview_150_Multidimensional_DP
+// #2025_05_20_Time_0_ms_(100.00%)_Space_12.50_MB_(32.12%)
+
+func maxProfit(prices []int) int {
+	if len(prices) == 0 {
+		return 0
+	}
+	fb := -1 << 31
+	sb := -1 << 31
+	fs := 0
+	ss := 0
+	for _, price := range prices {
+		fb = max(fb, -price)
+		fs = max(fs, fb+price)
+		sb = max(sb, fs-price)
+		ss = max(ss, sb+price)
+	}
+	return ss
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}

src/main/go/g0101_0200/s0123_best_time_to_buy_and_sell_stock_iii/solution.go

@@ -0,0 +1,26 @@
+package s0123_best_time_to_buy_and_sell_stock_iii
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestMaxProfit(t *testing.T) {
+	prices := []int{3, 3, 5, 0, 0, 3, 1, 4}
+	assert.Equal(t, 6, maxProfit(prices))
+}
+
+func TestMaxProfit2(t *testing.T) {
+	prices := []int{1, 2, 3, 4, 5}
+	assert.Equal(t, 4, maxProfit(prices))
+}
+
+func TestMaxProfit3(t *testing.T) {
+	prices := []int{7, 6, 4, 3, 1}
+	assert.Equal(t, 0, maxProfit(prices))
+}
+
+func TestMaxProfit4(t *testing.T) {
+	var prices []int
+	assert.Equal(t, 0, maxProfit(prices))
+}