Added tasks 36-117

Author: ThanhNIT

src/main/go/g0001_0100/s0086_partition_list/list_node.go

@@ -0,0 +1,6 @@
+package s0086_partition_list
+
+type ListNode struct {
+	Val  int
+	Next *ListNode
+}

src/main/go/g0001_0100/s0086_partition_list/readme.md

@@ -0,0 +1,27 @@
+86\. Partition List
+
+Medium
+
+Given the `head` of a linked list and a value `x`, partition it such that all nodes **less than** `x` come before nodes **greater than or equal** to `x`.
+
+You should **preserve** the original relative order of the nodes in each of the two partitions.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/01/04/partition.jpg)
+
+**Input:** head = [1,4,3,2,5,2], x = 3
+
+**Output:** [1,2,2,4,3,5]
+
+**Example 2:**
+
+**Input:** head = [2,1], x = 2
+
+**Output:** [1,2]
+
+**Constraints:**
+
+*   The number of nodes in the list is in the range `[0, 200]`.
+*   `-100 <= Node.val <= 100`
+*   `-200 <= x <= 200`

src/main/go/g0001_0100/s0086_partition_list/solution.go

@@ -0,0 +1,32 @@
+package s0086_partition_list
+
+// #Medium #Two_Pointers #Linked_List #Top_Interview_150_Linked_List
+// #2025_05_17_Time_0_ms_(100.00%)_Space_4.30_MB_(62.68%)
+
+/**
+ * Definition for singly-linked list.
+ * type ListNode struct {
+ *     Val int
+ *     Next *ListNode
+ * }
+ */
+func partition(head *ListNode, x int) *ListNode {
+	nHead := &ListNode{Val: 0}
+	nTail := &ListNode{Val: 0}
+	ptr := nTail
+	temp := nHead
+	for head != nil {
+		nNext := head.Next
+		if head.Val < x {
+			nHead.Next = head
+			nHead = nHead.Next
+		} else {
+			nTail.Next = head
+			nTail = nTail.Next
+		}
+		head = nNext
+	}
+	nTail.Next = nil
+	nHead.Next = ptr.Next
+	return temp.Next
+}

src/main/go/g0001_0100/s0086_partition_list/solution_test.go

@@ -0,0 +1,24 @@
+package s0086_partition_list
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestPartition(t *testing.T) {
+	head := &ListNode{Val: 1, Next: &ListNode{Val: 4, Next: &ListNode{Val: 3, Next: &ListNode{Val: 2, Next: &ListNode{Val: 5, Next: &ListNode{Val: 2}}}}}}
+	result := partition(head, 3)
+	assert.Equal(t, 1, result.Val)
+	assert.Equal(t, 2, result.Next.Val)
+	assert.Equal(t, 2, result.Next.Next.Val)
+	assert.Equal(t, 4, result.Next.Next.Next.Val)
+	assert.Equal(t, 3, result.Next.Next.Next.Next.Val)
+	assert.Equal(t, 5, result.Next.Next.Next.Next.Next.Val)
+}
+
+func TestPartition2(t *testing.T) {
+	head := &ListNode{Val: 2, Next: &ListNode{Val: 1}}
+	result := partition(head, 2)
+	assert.Equal(t, 1, result.Val)
+	assert.Equal(t, 2, result.Next.Val)
+}

src/main/go/g0001_0100/s0088_merge_sorted_array/readme.md

@@ -0,0 +1,43 @@
+88\. Merge Sorted Array
+
+Easy
+
+You are given two integer arrays `nums1` and `nums2`, sorted in **non-decreasing order**, and two integers `m` and `n`, representing the number of elements in `nums1` and `nums2` respectively.
+
+**Merge** `nums1` and `nums2` into a single array sorted in **non-decreasing order**.
+
+The final sorted array should not be returned by the function, but instead be _stored inside the array_ `nums1`. To accommodate this, `nums1` has a length of `m + n`, where the first `m` elements denote the elements that should be merged, and the last `n` elements are set to `0` and should be ignored. `nums2` has a length of `n`.
+
+**Example 1:**
+
+**Input:** nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
+
+**Output:** [1,2,2,3,5,6]
+
+**Explanation:** The arrays we are merging are [1,2,3] and [2,5,6]. The result of the merge is [<ins>1</ins>,<ins>2</ins>,2,<ins>3</ins>,5,6] with the underlined elements coming from nums1.
+
+**Example 2:**
+
+**Input:** nums1 = [1], m = 1, nums2 = [], n = 0
+
+**Output:** [1]
+
+**Explanation:** The arrays we are merging are [1] and []. The result of the merge is [1].
+
+**Example 3:**
+
+**Input:** nums1 = [0], m = 0, nums2 = [1], n = 1
+
+**Output:** [1]
+
+**Explanation:** The arrays we are merging are [] and [1]. The result of the merge is [1]. Note that because m = 0, there are no elements in nums1. The 0 is only there to ensure the merge result can fit in nums1.
+
+**Constraints:**
+
+*   `nums1.length == m + n`
+*   `nums2.length == n`
+*   `0 <= m, n <= 200`
+*   `1 <= m + n <= 200`
+*   <code>-10<sup>9</sup> <= nums1[i], nums2[j] <= 10<sup>9</sup></code>
+
+**Follow up:** Can you come up with an algorithm that runs in `O(m + n)` time?

src/main/go/g0001_0100/s0088_merge_sorted_array/solution.go

@@ -0,0 +1,21 @@
+package s0088_merge_sorted_array
+
+// #Easy #Top_Interview_Questions #Array #Sorting #Two_Pointers #Data_Structure_I_Day_2_Array
+// #Top_Interview_150_Array/String #2025_05_17_Time_0_ms_(100.00%)_Space_4.22_MB_(38.99%)
+
+func merge(nums1 []int, m int, nums2 []int, n int) {
+	i := m - 1
+	j := len(nums1) - 1
+	p2 := n - 1
+	for p2 >= 0 {
+		if i >= 0 && nums1[i] > nums2[p2] {
+			nums1[j] = nums1[i]
+			j--
+			i--
+		} else {
+			nums1[j] = nums2[p2]
+			j--
+			p2--
+		}
+	}
+}

src/main/go/g0001_0100/s0088_merge_sorted_array/solution_test.go

@@ -0,0 +1,27 @@
+package s0088_merge_sorted_array
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestMerge(t *testing.T) {
+	nums1 := []int{1, 2, 3, 0, 0, 0}
+	nums2 := []int{2, 5, 6}
+	merge(nums1, 3, nums2, 3)
+	assert.Equal(t, []int{1, 2, 2, 3, 5, 6}, nums1)
+}
+
+func TestMerge2(t *testing.T) {
+	nums1 := []int{1}
+	nums2 := []int{}
+	merge(nums1, 1, nums2, 0)
+	assert.Equal(t, []int{1}, nums1)
+}
+
+func TestMerge3(t *testing.T) {
+	nums1 := []int{0}
+	nums2 := []int{1}
+	merge(nums1, 0, nums2, 1)
+	assert.Equal(t, []int{1}, nums1)
+}

src/main/go/g0001_0100/s0092_reverse_linked_list_ii/list_node.go

@@ -0,0 +1,6 @@
+package s0092_reverse_linked_list_ii
+
+type ListNode struct {
+	Val  int
+	Next *ListNode
+}

src/main/go/g0001_0100/s0092_reverse_linked_list_ii/readme.md

@@ -0,0 +1,28 @@
+92\. Reverse Linked List II
+
+Medium
+
+Given the `head` of a singly linked list and two integers `left` and `right` where `left <= right`, reverse the nodes of the list from position `left` to position `right`, and return _the reversed list_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/02/19/rev2ex2.jpg)
+
+**Input:** head = [1,2,3,4,5], left = 2, right = 4
+
+**Output:** [1,4,3,2,5]
+
+**Example 2:**
+
+**Input:** head = [5], left = 1, right = 1
+
+**Output:** [5]
+
+**Constraints:**
+
+*   The number of nodes in the list is `n`.
+*   `1 <= n <= 500`
+*   `-500 <= Node.val <= 500`
+*   `1 <= left <= right <= n`
+
+**Follow up:** Could you do it in one pass?

src/main/go/g0001_0100/s0092_reverse_linked_list_ii/solution.go

@@ -0,0 +1,66 @@
+package s0092_reverse_linked_list_ii
+
+// #Medium #Linked_List #Top_Interview_150_Linked_List
+// #2025_05_17_Time_0_ms_(100.00%)_Space_4.09_MB_(56.36%)
+
+/**
+ * Definition for singly-linked list.
+ * type ListNode struct {
+ *     Val int
+ *     Next *ListNode
+ * }
+ */
+func reverseBetween(head *ListNode, left int, right int) *ListNode {
+	if left == right {
+		return head
+	}
+	var prev *ListNode
+	temp := head
+	var start *ListNode
+	k := left
+	for temp != nil && k > 1 {
+		prev = temp
+		temp = temp.Next
+		k--
+	}
+	if left > 1 && prev != nil {
+		prev.Next = nil
+	}
+	var prev1 *ListNode
+	start = temp
+	for temp != nil && right-left >= 0 {
+		prev1 = temp
+		temp = temp.Next
+		right--
+	}
+	if prev1 != nil {
+		prev1.Next = nil
+	}
+	if left > 1 && prev != nil {
+		prev.Next = reverse(start)
+	} else {
+		head = reverse(start)
+		prev = head
+	}
+	for prev.Next != nil {
+		prev = prev.Next
+	}
+	prev.Next = temp
+	return head
+}
+
+func reverse(head *ListNode) *ListNode {
+	var p, q, r *ListNode
+	p = head
+	for p != nil {
+		q = p.Next
+		p.Next = r
+		r = p
+		p = q
+	}
+	return r
+}
+
+func decode(s string) string {
+	return s
+}

src/main/go/g0001_0100/s0092_reverse_linked_list_ii/solution_test.go

@@ -0,0 +1,28 @@
+package s0092_reverse_linked_list_ii
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestReverseBetween(t *testing.T) {
+	head := &ListNode{Val: 1}
+	head.Next = &ListNode{Val: 2}
+	head.Next.Next = &ListNode{Val: 3}
+	head.Next.Next.Next = &ListNode{Val: 4}
+	head.Next.Next.Next.Next = &ListNode{Val: 5}
+
+	result := reverseBetween(head, 2, 4)
+	assert.Equal(t, 1, result.Val)
+	assert.Equal(t, 4, result.Next.Val)
+	assert.Equal(t, 3, result.Next.Next.Val)
+	assert.Equal(t, 2, result.Next.Next.Next.Val)
+	assert.Equal(t, 5, result.Next.Next.Next.Next.Val)
+}
+
+func TestReverseBetween2(t *testing.T) {
+	head := &ListNode{Val: 5}
+
+	result := reverseBetween(head, 1, 1)
+	assert.Equal(t, 5, result.Val)
+}

src/main/go/g0001_0100/s0097_interleaving_string/readme.md

@@ -0,0 +1,46 @@
+97\. Interleaving String
+
+Medium
+
+Given strings `s1`, `s2`, and `s3`, find whether `s3` is formed by an **interleaving** of `s1` and `s2`.
+
+An **interleaving** of two strings `s` and `t` is a configuration where `s` and `t` are divided into `n` and `m` **non-empty** substrings respectively, such that:
+
+*   <code>s = s<sub>1</sub> + s<sub>2</sub> + ... + s<sub>n</sub></code>
+*   <code>t = t<sub>1</sub> + t<sub>2</sub> + ... + t<sub>m</sub></code>
+*   `|n - m| <= 1`
+*   The **interleaving** is <code>s<sub>1</sub> + t<sub>1</sub> + s<sub>2</sub> + t<sub>2</sub> + s<sub>3</sub> + t<sub>3</sub> + ...</code> or <code>t<sub>1</sub> + s<sub>1</sub> + t<sub>2</sub> + s<sub>2</sub> + t<sub>3</sub> + s<sub>3</sub> + ...</code>
+
+**Note:** `a + b` is the concatenation of strings `a` and `b`.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/09/02/interleave.jpg)
+
+**Input:** s1 = "aabcc", s2 = "dbbca", s3 = "aadbbcbcac"
+
+**Output:** true
+
+**Explanation:** One way to obtain s3 is: Split s1 into s1 = "aa" + "bc" + "c", and s2 into s2 = "dbbc" + "a". Interleaving the two splits, we get "aa" + "dbbc" + "bc" + "a" + "c" = "aadbbcbcac". Since s3 can be obtained by interleaving s1 and s2, we return true.
+
+**Example 2:**
+
+**Input:** s1 = "aabcc", s2 = "dbbca", s3 = "aadbbbaccc"
+
+**Output:** false
+
+**Explanation:** Notice how it is impossible to interleave s2 with any other string to obtain s3.
+
+**Example 3:**
+
+**Input:** s1 = "", s2 = "", s3 = ""
+
+**Output:** true
+
+**Constraints:**
+
+*   `0 <= s1.length, s2.length <= 100`
+*   `0 <= s3.length <= 200`
+*   `s1`, `s2`, and `s3` consist of lowercase English letters.
+
+**Follow up:** Could you solve it using only `O(s2.length)` additional memory space?

src/main/go/g0001_0100/s0097_interleaving_string/solution.go

@@ -0,0 +1,33 @@
+package s0097_interleaving_string
+
+// #Medium #String #Dynamic_Programming #Top_Interview_150_Multidimensional_DP
+// #2025_05_17_Time_0_ms_(100.00%)_Space_4.85_MB_(28.57%)
+
+func isInterleave(s1 string, s2 string, s3 string) bool {
+	if len(s3) != len(s1)+len(s2) {
+		return false
+	}
+	cache := make([][]*bool, len(s1)+1)
+	for i := range cache {
+		cache[i] = make([]*bool, len(s2)+1)
+	}
+	return isInterleaveHelper(s1, s2, s3, 0, 0, 0, cache)
+}
+
+func isInterleaveHelper(s1, s2, s3 string, i1, i2, i3 int, cache [][]*bool) bool {
+	if cache[i1][i2] != nil {
+		return *cache[i1][i2]
+	}
+	if i1 == len(s1) && i2 == len(s2) && i3 == len(s3) {
+		return true
+	}
+	result := false
+	if i1 < len(s1) && s1[i1] == s3[i3] {
+		result = isInterleaveHelper(s1, s2, s3, i1+1, i2, i3+1, cache)
+	}
+	if i2 < len(s2) && s2[i2] == s3[i3] {
+		result = result || isInterleaveHelper(s1, s2, s3, i1, i2+1, i3+1, cache)
+	}
+	cache[i1][i2] = &result
+	return result
+}