Added tasks 86-100

Author: ThanhNIT

LeetCodeNet.Tests/G0001_0100/S0086_partition_list/SolutionTest.cs

@@ -0,0 +1,50 @@
+namespace LeetCodeNet.G0001_0100.S0086_partition_list {
+
+using Xunit;
+using LeetCodeNet.Com_github_leetcode;
+
+public class SolutionTest {
+    private ListNode BuildList(int[] vals) {
+        ListNode dummy = new ListNode(0);
+        ListNode curr = dummy;
+        foreach (var v in vals) {
+            curr.next = new ListNode(v);
+            curr = curr.next;
+        }
+        return dummy.next;
+    }
+
+    private int[] ToArray(ListNode head) {
+        var list = new List<int>();
+        while (head != null) {
+            list.Add(head.val);
+            head = head.next;
+        }
+        return list.ToArray();
+    }
+
+    [Fact]
+    public void Partition() {
+        var solution = new Solution();
+        var head = BuildList(new int[] {1,4,3,2,5,2});
+        var result = solution.Partition(head, 3);
+        Assert.Equal(new int[] {1,2,2,4,3,5}, ToArray(result));
+    }
+
+    [Fact]
+    public void Partition2() {
+        var solution = new Solution();
+        var head = BuildList(new int[] {2,1});
+        var result = solution.Partition(head, 2);
+        Assert.Equal(new int[] {1,2}, ToArray(result));
+    }
+
+    [Fact]
+    public void Partition3() {
+        var solution = new Solution();
+        var head = BuildList(new int[] {1,2,3});
+        var result = solution.Partition(head, 5);
+        Assert.Equal(new int[] {1,2,3}, ToArray(result));
+    }
+}
+}

LeetCodeNet.Tests/G0001_0100/S0088_merge_sorted_array/SolutionTest.cs

@@ -0,0 +1,33 @@
+namespace LeetCodeNet.G0001_0100.S0088_merge_sorted_array {
+
+using Xunit;
+
+public class SolutionTest {
+    [Fact]
+    public void Merge() {
+        var solution = new Solution();
+        int[] nums1 = {1,2,3,0,0,0};
+        int[] nums2 = {2,5,6};
+        solution.Merge(nums1, 3, nums2, 3);
+        Assert.Equal(new int[] {1,2,2,3,5,6}, nums1);
+    }
+
+    [Fact]
+    public void Merge2() {
+        var solution = new Solution();
+        int[] nums1 = {1};
+        int[] nums2 = {};
+        solution.Merge(nums1, 1, nums2, 0);
+        Assert.Equal(new int[] {1}, nums1);
+    }
+
+    [Fact]
+    public void Merge3() {
+        var solution = new Solution();
+        int[] nums1 = {0};
+        int[] nums2 = {1};
+        solution.Merge(nums1, 0, nums2, 1);
+        Assert.Equal(new int[] {1}, nums1);
+    }
+}
+}

LeetCodeNet.Tests/G0001_0100/S0092_reverse_linked_list_ii/SolutionTest.cs

@@ -0,0 +1,50 @@
+namespace LeetCodeNet.G0001_0100.S0092_reverse_linked_list_ii {
+
+using Xunit;
+using LeetCodeNet.Com_github_leetcode;
+
+public class SolutionTest {
+    private ListNode BuildList(int[] vals) {
+        ListNode dummy = new ListNode(0);
+        ListNode curr = dummy;
+        foreach (var v in vals) {
+            curr.next = new ListNode(v);
+            curr = curr.next;
+        }
+        return dummy.next;
+    }
+
+    private int[] ToArray(ListNode head) {
+        var list = new System.Collections.Generic.List<int>();
+        while (head != null) {
+            list.Add(head.val);
+            head = head.next;
+        }
+        return list.ToArray();
+    }
+
+    [Fact]
+    public void ReverseBetween() {
+        var solution = new Solution();
+        var head = BuildList(new int[] {1,2,3,4,5});
+        var result = solution.ReverseBetween(head, 2, 4);
+        Assert.Equal(new int[] {1,4,3,2,5}, ToArray(result));
+    }
+
+    [Fact]
+    public void ReverseBetween2() {
+        var solution = new Solution();
+        var head = BuildList(new int[] {5});
+        var result = solution.ReverseBetween(head, 1, 1);
+        Assert.Equal(new int[] {5}, ToArray(result));
+    }
+
+    [Fact]
+    public void ReverseBetween3() {
+        var solution = new Solution();
+        var head = BuildList(new int[] {1,2,3});
+        var result = solution.ReverseBetween(head, 1, 3);
+        Assert.Equal(new int[] {3,2,1}, ToArray(result));
+    }
+}
+}

LeetCodeNet.Tests/G0001_0100/S0097_interleaving_string/SolutionTest.cs

@@ -0,0 +1,30 @@
+namespace LeetCodeNet.G0001_0100.S0097_interleaving_string {
+
+using Xunit;
+
+public class SolutionTest {
+    [Fact]
+    public void IsInterleave() {
+        var solution = new Solution();
+        Assert.True(solution.IsInterleave("aabcc", "dbbca", "aadbbcbcac"));
+    }
+
+    [Fact]
+    public void IsInterleave2() {
+        var solution = new Solution();
+        Assert.False(solution.IsInterleave("aabcc", "dbbca", "aadbbbaccc"));
+    }
+
+    [Fact]
+    public void IsInterleave3() {
+        var solution = new Solution();
+        Assert.True(solution.IsInterleave("", "", ""));
+    }
+
+    [Fact]
+    public void IsInterleave4() {
+        var solution = new Solution();
+        Assert.False(solution.IsInterleave("a", "b", "abc"));
+    }
+}
+}

LeetCodeNet.Tests/G0001_0100/S0100_same_tree/SolutionTest.cs

@@ -0,0 +1,45 @@
+namespace LeetCodeNet.G0001_0100.S0100_same_tree {
+
+using Xunit;
+using LeetCodeNet.Com_github_leetcode;
+
+public class SolutionTest {
+    private TreeNode BuildTree(int?[] vals, int index = 0) {
+        if (index >= vals.Length || vals[index] == null) return null;
+        TreeNode root = new TreeNode(vals[index].Value);
+        root.left = BuildTree(vals, 2 * index + 1);
+        root.right = BuildTree(vals, 2 * index + 2);
+        return root;
+    }
+
+    [Fact]
+    public void IsSameTree() {
+        var solution = new Solution();
+        var p = BuildTree(new int?[] {1, 2, 3});
+        var q = BuildTree(new int?[] {1, 2, 3});
+        Assert.True(solution.IsSameTree(p, q));
+    }
+
+    [Fact]
+    public void IsSameTree2() {
+        var solution = new Solution();
+        var p = BuildTree(new int?[] {1, 2});
+        var q = BuildTree(new int?[] {1, null, 2});
+        Assert.False(solution.IsSameTree(p, q));
+    }
+
+    [Fact]
+    public void IsSameTree3() {
+        var solution = new Solution();
+        var p = BuildTree(new int?[] {1, 2, 1});
+        var q = BuildTree(new int?[] {1, 1, 2});
+        Assert.False(solution.IsSameTree(p, q));
+    }
+
+    [Fact]
+    public void IsSameTree4() {
+        var solution = new Solution();
+        Assert.True(solution.IsSameTree(null, null));
+    }
+}
+}

LeetCodeNet/G0001_0100/S0086_partition_list/Solution.cs

@@ -0,0 +1,40 @@
+namespace LeetCodeNet.G0001_0100.S0086_partition_list {
+
+// #Medium #Two_Pointers #Linked_List #Top_Interview_150_Linked_List
+// #2025_07_05_Time_0_ms_(100.00%)_Space_42.69_MB_(64.54%)
+
+using LeetCodeNet.Com_github_leetcode;
+
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public int val;
+ *     public ListNode next;
+ *     public ListNode(int val=0, ListNode next=null) {
+ *         this.val = val;
+ *         this.next = next;
+ *     }
+ * }
+ */
+public class Solution {
+    public ListNode Partition(ListNode head, int x) {
+        ListNode beforeHead = new ListNode(0);
+        ListNode afterHead = new ListNode(0);
+        ListNode before = beforeHead;
+        ListNode after = afterHead;
+        while (head != null) {
+            if (head.val < x) {
+                before.next = head;
+                before = before.next;
+            } else {
+                after.next = head;
+                after = after.next;
+            }
+            head = head.next;
+        }
+        after.next = null;
+        before.next = afterHead.next;
+        return beforeHead.next;
+    }
+}
+}

LeetCodeNet/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`

LeetCodeNet/G0001_0100/S0088_merge_sorted_array/Solution.cs

@@ -0,0 +1,23 @@
+namespace LeetCodeNet.G0001_0100.S0088_merge_sorted_array {
+
+// #Easy #Top_Interview_Questions #Array #Sorting #Two_Pointers #Data_Structure_I_Day_2_Array
+// #Top_Interview_150_Array/String #2025_07_05_Time_0_ms_(100.00%)_Space_46.88_MB_(90.46%)
+
+public class Solution {
+    public void Merge(int[] nums1, int m, int[] nums2, int n) {
+        int i = m - 1; 
+        int j = n - 1; 
+        int k = m + n - 1;
+        while (i >= 0 && j >= 0) {
+            if (nums1[i] > nums2[j]) {
+                nums1[k--] = nums1[i--];
+            } else {
+                nums1[k--] = nums2[j--];
+            }
+        }
+        while (j >= 0) {
+            nums1[k--] = nums2[j--];
+        }
+    }
+}
+}

LeetCodeNet/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 [1,2,2,3,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?

LeetCodeNet/G0001_0100/S0092_reverse_linked_list_ii/Solution.cs

@@ -0,0 +1,39 @@
+namespace LeetCodeNet.G0001_0100.S0092_reverse_linked_list_ii {
+
+// #Medium #Linked_List #Top_Interview_150_Linked_List
+// #2025_07_05_Time_0_ms_(100.00%)_Space_41.68_MB_(85.47%)
+
+using LeetCodeNet.Com_github_leetcode;
+
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public int val;
+ *     public ListNode next;
+ *     public ListNode(int val=0, ListNode next=null) {
+ *         this.val = val;
+ *         this.next = next;
+ *     }
+ * }
+ */
+public class Solution {
+    public ListNode ReverseBetween(ListNode head, int left, int right) {
+        if (head == null || left == right) {
+            return head;
+        }
+        ListNode dummy = new ListNode(0, head);
+        ListNode prev = dummy;
+        for (int i = 0; i < left - 1; i++) {
+            prev = prev.next;
+        }
+        ListNode curr = prev.next;
+        for (int i = 0; i < right - left; i++) {
+            ListNode next = curr.next;
+            curr.next = next.next;
+            next.next = prev.next;
+            prev.next = next;
+        }
+        return dummy.next;
+    }
+}
+}