Added tasks 69-82

Author: ThanhNIT

LeetCodeNet.Tests/G0001_0100/S0069_sqrtx/SolutionTest.cs

@@ -0,0 +1,36 @@
+namespace LeetCodeNet.G0001_0100.S0069_sqrtx {
+
+using Xunit;
+
+public class SolutionTest {
+    [Fact]
+    public void MySqrt() {
+        var solution = new Solution();
+        Assert.Equal(2, solution.MySqrt(4));
+    }
+
+    [Fact]
+    public void MySqrt2() {
+        var solution = new Solution();
+        Assert.Equal(2, solution.MySqrt(8));
+    }
+
+    [Fact]
+    public void MySqrt3() {
+        var solution = new Solution();
+        Assert.Equal(0, solution.MySqrt(0));
+    }
+
+    [Fact]
+    public void MySqrt4() {
+        var solution = new Solution();
+        Assert.Equal(1, solution.MySqrt(1));
+    }
+
+    [Fact]
+    public void MySqrt5() {
+        var solution = new Solution();
+        Assert.Equal(46340, solution.MySqrt(2147395600));
+    }
+}
+}

LeetCodeNet.Tests/G0001_0100/S0071_simplify_path/SolutionTest.cs

@@ -0,0 +1,36 @@
+namespace LeetCodeNet.G0001_0100.S0071_simplify_path {
+
+using Xunit;
+
+public class SolutionTest {
+    [Fact]
+    public void SimplifyPath() {
+        var solution = new Solution();
+        Assert.Equal("/home", solution.SimplifyPath("/home/"));
+    }
+
+    [Fact]
+    public void SimplifyPath2() {
+        var solution = new Solution();
+        Assert.Equal("/", solution.SimplifyPath("/../"));
+    }
+
+    [Fact]
+    public void SimplifyPath3() {
+        var solution = new Solution();
+        Assert.Equal("/home/foo", solution.SimplifyPath("/home//foo/"));
+    }
+
+    [Fact]
+    public void SimplifyPath4() {
+        var solution = new Solution();
+        Assert.Equal("/c", solution.SimplifyPath("/a/./b/../../c/"));
+    }
+
+    [Fact]
+    public void SimplifyPath5() {
+        var solution = new Solution();
+        Assert.Equal("/a/b/c", solution.SimplifyPath("/a//b////c/d//././/.."));
+    }
+}
+}

LeetCodeNet.Tests/G0001_0100/S0077_combinations/SolutionTest.cs

@@ -0,0 +1,32 @@
+namespace LeetCodeNet.G0001_0100.S0077_combinations {
+
+using Xunit;
+using System.Collections.Generic;
+using System.Linq;
+
+public class SolutionTest {
+    private List<List<int>> SortCombinations(IList<IList<int>> combos) {
+        return combos.Select(x => x.OrderBy(i => i).ToList()).OrderBy(x => string.Join(",", x)).ToList();
+    }
+
+    [Fact]
+    public void Combine() {
+        var solution = new Solution();
+        IList<IList<int>> expected = new List<IList<int>> {
+            new List<int> {2,4}, new List<int> {3,4}, new List<int> {2,3}, new List<int> {1,2}, new List<int> {1,3}, new List<int> {1,4}
+        };
+        var result = solution.Combine(4, 2);
+        Assert.Equal(SortCombinations(expected), SortCombinations(result));
+    }
+
+    [Fact]
+    public void Combine2() {
+        var solution = new Solution();
+        var expected = new List<IList<int>> {
+            new List<int> {1}
+        };
+            var result = solution.Combine(1, 1);
+        Assert.Equal(SortCombinations(expected), SortCombinations(result));
+    }
+}
+}

LeetCodeNet.Tests/G0001_0100/S0080_remove_duplicates_from_sorted_array_ii/SolutionTest.cs

@@ -0,0 +1,33 @@
+namespace LeetCodeNet.G0001_0100.S0080_remove_duplicates_from_sorted_array_ii {
+    
+using Xunit;
+
+public class SolutionTest {
+    [Fact]
+    public void RemoveDuplicates() {
+        var solution = new Solution();
+        int[] nums = {1,1,1,2,2,3};
+        int k = solution.RemoveDuplicates(nums);
+        Assert.Equal(5, k);
+        Assert.Equal(new int[] {1,1,2,2,3}, nums[..k]);
+    }
+
+    [Fact]
+    public void RemoveDuplicates2() {
+        var solution = new Solution();
+        int[] nums = {0,0,1,1,1,1,2,3,3};
+        int k = solution.RemoveDuplicates(nums);
+        Assert.Equal(7, k);
+        Assert.Equal(new int[] {0,0,1,1,2,3,3}, nums[..k]);
+    }
+
+    [Fact]
+    public void RemoveDuplicates3() {
+        var solution = new Solution();
+        int[] nums = {1,2,3,4};
+        int k = solution.RemoveDuplicates(nums);
+        Assert.Equal(4, k);
+        Assert.Equal(new int[] {1,2,3,4}, nums[..k]);
+    }
+}
+}

LeetCodeNet.Tests/G0001_0100/S0082_remove_duplicates_from_sorted_list_ii/SolutionTest.cs

@@ -0,0 +1,50 @@
+namespace LeetCodeNet.G0001_0100.S0082_remove_duplicates_from_sorted_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 DeleteDuplicates() {
+        var solution = new Solution();
+        var head = BuildList(new int[] {1,2,3,3,4,4,5});
+        var result = solution.DeleteDuplicates(head);
+        Assert.Equal(new int[] {1,2,5}, ToArray(result));
+    }
+
+    [Fact]
+    public void DeleteDuplicates2() {
+        var solution = new Solution();
+        var head = BuildList(new int[] {1,1,1,2,3});
+        var result = solution.DeleteDuplicates(head);
+        Assert.Equal(new int[] {2,3}, ToArray(result));
+    }
+
+    [Fact]
+    public void DeleteDuplicates3() {
+        var solution = new Solution();
+        var head = BuildList(new int[] {1,2,3});
+        var result = solution.DeleteDuplicates(head);
+        Assert.Equal(new int[] {1,2,3}, ToArray(result));
+    }
+}
+}

LeetCodeNet/G0001_0100/S0069_sqrtx/Solution.cs

@@ -0,0 +1,29 @@
+namespace LeetCodeNet.G0001_0100.S0069_sqrtx {
+
+// #Easy #Top_Interview_Questions #Math #Binary_Search #Binary_Search_I_Day_4
+// #Top_Interview_150_Math #2025_07_04_Time_0_ms_(100.00%)_Space_29.30_MB_(44.18%)
+
+public class Solution {
+    public int MySqrt(int x) {
+        if (x < 2) {
+            return x;
+        }
+        int left = 1;
+        int right = x / 2;
+        int ans = 0;
+        while (left <= right) {
+            int mid = left + (right - left) / 2;
+            if ((long)mid * mid == x) {
+                return mid;
+            }
+            if ((long)mid * mid < x) {
+                ans = mid;
+                left = mid + 1;
+            } else {
+                right = mid - 1;
+            }
+        }
+        return ans;
+    }
+}
+}

LeetCodeNet/G0001_0100/S0069_sqrtx/readme.md

@@ -0,0 +1,27 @@
+69\. Sqrt(x)
+
+Easy
+
+Given a non-negative integer `x`, compute and return _the square root of_ `x`.
+
+Since the return type is an integer, the decimal digits are **truncated**, and only **the integer part** of the result is returned.
+
+**Note:** You are not allowed to use any built-in exponent function or operator, such as `pow(x, 0.5)` or `x ** 0.5`.
+
+**Example 1:**
+
+**Input:** x = 4
+
+**Output:** 2 
+
+**Example 2:**
+
+**Input:** x = 8
+
+**Output:** 2
+
+**Explanation:** The square root of 8 is 2.82842..., and since the decimal part is truncated, 2 is returned.
+
+**Constraints:**
+
+*   <code>0 <= x <= 2<sup>31</sup> - 1</code>

LeetCodeNet/G0001_0100/S0071_simplify_path/Solution.cs

@@ -0,0 +1,27 @@
+namespace LeetCodeNet.G0001_0100.S0071_simplify_path {
+
+// #Medium #String #Stack #Top_Interview_150_Stack
+// #2025_07_04_Time_2_ms_(90.87%)_Space_42.38_MB_(89.63%)
+
+public class Solution {
+    public string SimplifyPath(string path) {
+        var parts = path.Split('/');
+        var newParts = new List<string>();
+        for (var i = 0; i < parts.Length; i++) {
+            if (parts[i] == string.Empty) {
+                continue;
+            }
+            if (parts[i] == ".") {
+                continue;
+            }
+            if (parts[i] == "..") {
+                if (newParts.Count > 0)
+                    newParts.RemoveAt(newParts.Count - 1);
+                continue;
+            }
+            newParts.Add(parts[i]);
+        }
+        return $"/{string.Join("/", newParts)}";
+    }
+}
+}

LeetCodeNet/G0001_0100/S0071_simplify_path/readme.md

@@ -0,0 +1,52 @@
+71\. Simplify Path
+
+Medium
+
+Given a string `path`, which is an **absolute path** (starting with a slash `'/'`) to a file or directory in a Unix-style file system, convert it to the simplified **canonical path**.
+
+In a Unix-style file system, a period `'.'` refers to the current directory, a double period `'..'` refers to the directory up a level, and any multiple consecutive slashes (i.e. `'//'`) are treated as a single slash `'/'`. For this problem, any other format of periods such as `'...'` are treated as file/directory names.
+
+The **canonical path** should have the following format:
+
+*   The path starts with a single slash `'/'`.
+*   Any two directories are separated by a single slash `'/'`.
+*   The path does not end with a trailing `'/'`.
+*   The path only contains the directories on the path from the root directory to the target file or directory (i.e., no period `'.'` or double period `'..'`)
+
+Return _the simplified **canonical path**_.
+
+**Example 1:**
+
+**Input:** path = "/home/"
+
+**Output:** "/home"
+
+**Explanation:** Note that there is no trailing slash after the last directory name. 
+
+**Example 2:**
+
+**Input:** path = "/../"
+
+**Output:** "/"
+
+**Explanation:** Going one level up from the root directory is a no-op, as the root level is the highest level you can go. 
+
+**Example 3:**
+
+**Input:** path = "/home//foo/"
+
+**Output:** "/home/foo"
+
+**Explanation:** In the canonical path, multiple consecutive slashes are replaced by a single one. 
+
+**Example 4:**
+
+**Input:** path = "/a/./b/../../c/"
+
+**Output:** "/c" 
+
+**Constraints:**
+
+*   `1 <= path.length <= 3000`
+*   `path` consists of English letters, digits, period `'.'`, slash `'/'` or `'_'`.
+*   `path` is a valid absolute Unix path.

LeetCodeNet/G0001_0100/S0077_combinations/Solution.cs

@@ -0,0 +1,24 @@
+namespace LeetCodeNet.G0001_0100.S0077_combinations {
+
+// #Medium #Backtracking #Algorithm_I_Day_11_Recursion_Backtracking #Top_Interview_150_Backtracking
+// #2025_07_04_Time_29_ms_(89.17%)_Space_97.46_MB_(59.96%)
+
+public class Solution {
+    public IList<IList<int>> Combine(int n, int k) {
+        var res = new List<IList<int>>();
+        Backtrack(1, n, k, new List<int>(), res);
+        return res;
+    }
+    private void Backtrack(int start, int n, int k, List<int> curr, List<IList<int>> res) {
+        if (curr.Count == k) {
+            res.Add(new List<int>(curr));
+            return;
+        }
+        for (int i = start; i <= n; i++) {
+            curr.Add(i);
+            Backtrack(i + 1, n, k, curr, res);
+            curr.RemoveAt(curr.Count - 1);
+        }
+    }
+}
+}