Added tasks 26-36

Author: ThanhNIT

LeetCodeNet.Tests/G0001_0100/S0026_remove_duplicates_from_sorted_array/SolutionTest.cs

@@ -0,0 +1,30 @@
+namespace LeetCodeNet.G0001_0100.S0026_remove_duplicates_from_sorted_array {
+
+using Xunit;
+
+public class SolutionTest {
+    [Fact]
+    public void RemoveDuplicates() {
+        var solution = new Solution();
+        var nums = new int[] { 1, 1, 2 };
+        var expectedNums = new int[] { 1, 2 };
+        var k = solution.RemoveDuplicates(nums);
+        Assert.Equal(expectedNums.Length, k);
+        for (int i = 0; i < k; i++) {
+            Assert.Equal(expectedNums[i], nums[i]);
+        }
+    }
+
+    [Fact]
+    public void RemoveDuplicates2() {
+        var solution = new Solution();
+        var nums = new int[] { 0, 0, 1, 1, 1, 2, 2, 3, 3, 4 };
+        var expectedNums = new int[] { 0, 1, 2, 3, 4 };
+        var k = solution.RemoveDuplicates(nums);
+        Assert.Equal(expectedNums.Length, k);
+        for (int i = 0; i < k; i++) {
+            Assert.Equal(expectedNums[i], nums[i]);
+        }
+    }
+}
+}

LeetCodeNet.Tests/G0001_0100/S0027_remove_element/SolutionTest.cs

@@ -0,0 +1,34 @@
+using System.Linq;
+
+namespace LeetCodeNet.G0001_0100.S0027_remove_element {
+
+using Xunit;
+
+public class SolutionTest {
+    [Fact]
+    public void RemoveElement() {
+        var solution = new Solution();
+        var nums = new int[] { 3, 2, 2, 3 };
+        var val = 3;
+        var expectedNums = new int[] { 2, 2 };
+        var k = solution.RemoveElement(nums, val);
+        Assert.Equal(expectedNums.Length, k);
+        var actualNums = nums.Take(k).ToArray();
+        System.Array.Sort(actualNums);
+        Assert.Equal(expectedNums, actualNums);
+    }
+
+    [Fact]
+    public void RemoveElement2() {
+        var solution = new Solution();
+        var nums = new int[] { 0, 1, 2, 2, 3, 0, 4, 2 };
+        var val = 2;
+        var expectedNums = new int[] { 0, 0, 1, 3, 4 };
+        var k = solution.RemoveElement(nums, val);
+        Assert.Equal(expectedNums.Length, k);
+        var actualNums = nums.Take(k).ToArray();
+        System.Array.Sort(actualNums);
+        Assert.Equal(expectedNums, actualNums);
+    }
+}
+}

LeetCodeNet.Tests/G0001_0100/S0028_find_the_index_of_the_first_occurrence_in_a_string/SolutionTest.cs

@@ -0,0 +1,21 @@
+namespace LeetCodeNet.G0001_0100.S0028_find_the_index_of_the_first_occurrence_in_a_string {
+
+using Xunit;
+
+public class SolutionTest {
+    [Fact]
+    public void StrStr() {
+        Assert.Equal(0, new Solution().StrStr("sadbutsad", "sad"));
+    }
+
+    [Fact]
+    public void StrStr2() {
+        Assert.Equal(-1, new Solution().StrStr("leetcode", "leeto"));
+    }
+
+    [Fact]
+    public void StrStr3() {
+        Assert.Equal(0, new Solution().StrStr("", ""));
+    }
+}
+}

LeetCodeNet.Tests/G0001_0100/S0030_substring_with_concatenation_of_all_words/SolutionTest.cs

@@ -0,0 +1,35 @@
+using System.Collections.Generic;
+using Xunit;
+
+namespace LeetCodeNet.G0001_0100.S0030_substring_with_concatenation_of_all_words {
+    public class SolutionTest {
+        [Fact]
+        public void FindSubstring() {
+            var solution = new Solution();
+            var result = solution.FindSubstring("barfoothefoobarman", new string[] { "foo", "bar" });
+            var expected = new List<int> { 0, 9 };
+            var resultList = new List<int>(result);
+            resultList.Sort();
+            expected.Sort();
+            Assert.Equal(expected, resultList);
+        }
+
+        [Fact]
+        public void FindSubstring2() {
+            var solution = new Solution();
+            var result = solution.FindSubstring("wordgoodgoodgoodbestword", new string[] { "word", "good", "best", "word" });
+            Assert.Equal(new List<int>(), result);
+        }
+
+        [Fact]
+        public void FindSubstring3() {
+            var solution = new Solution();
+            var result = solution.FindSubstring("barfoofoobarthefoobarman", new string[] { "bar", "foo", "the" });
+            var expected = new List<int> { 6, 9, 12 };
+            var resultList = new List<int>(result);
+            resultList.Sort();
+            expected.Sort();
+            Assert.Equal(expected, resultList);
+        }
+    }
+}

LeetCodeNet.Tests/G0001_0100/S0036_valid_sudoku/SolutionTest.cs

@@ -0,0 +1,39 @@
+using Xunit;
+
+namespace LeetCodeNet.G0001_0100.S0036_valid_sudoku {
+    public class SolutionTest {
+        [Fact]
+        public void IsValidSudoku_ValidBoard() {
+            var solution = new Solution();
+            var board = new char[][] {
+                new char[] {'5','3','.','.','7','.','.','.','.'},
+                new char[] {'6','.','.','1','9','5','.','.','.'},
+                new char[] {'.','9','8','.','.','.','.','6','.'},
+                new char[] {'8','.','.','.','6','.','.','.','3'},
+                new char[] {'4','.','.','8','.','3','.','.','1'},
+                new char[] {'7','.','.','.','2','.','.','.','6'},
+                new char[] {'.','6','.','.','.','.','2','8','.'},
+                new char[] {'.','.','.','4','1','9','.','.','5'},
+                new char[] {'.','.','.','.','8','.','.','7','9'}
+            };
+            Assert.True(solution.IsValidSudoku(board));
+        }
+
+        [Fact]
+        public void IsValidSudoku_InvalidBoard() {
+            var solution = new Solution();
+            var board = new char[][] {
+                new char[] {'8','3','.','.','7','.','.','.','.'},
+                new char[] {'6','.','.','1','9','5','.','.','.'},
+                new char[] {'.','9','8','.','.','.','.','6','.'},
+                new char[] {'8','.','.','.','6','.','.','.','3'},
+                new char[] {'4','.','.','8','.','3','.','.','1'},
+                new char[] {'7','.','.','.','2','.','.','.','6'},
+                new char[] {'.','6','.','.','.','.','2','8','.'},
+                new char[] {'.','.','.','4','1','9','.','.','5'},
+                new char[] {'.','.','.','.','8','.','.','7','9'}
+            };
+            Assert.False(solution.IsValidSudoku(board));
+        }
+    }
+}

LeetCodeNet/G0001_0100/S0026_remove_duplicates_from_sorted_array/Solution.cs

@@ -0,0 +1,21 @@
+namespace LeetCodeNet.G0001_0100.S0026_remove_duplicates_from_sorted_array {
+
+// #Easy #Top_Interview_Questions #Array #Two_Pointers #Udemy_Two_Pointers
+// #Top_Interview_150_Array/String #2025_06_30_Time_0_ms_(100.00%)_Space_50.94_MB_(81.18%)
+
+public class Solution {
+    public int RemoveDuplicates(int[] nums) {
+        if (nums.Length == 0) {
+            return 0;
+        }
+        int i = 0;
+        for (int j = 1; j < nums.Length; j++) {
+            if (nums[j] != nums[i]) {
+                i++;
+                nums[i] = nums[j];
+            }
+        }
+        return i + 1;
+    }
+}
+}

LeetCodeNet/G0001_0100/S0026_remove_duplicates_from_sorted_array/readme.md

@@ -0,0 +1,49 @@
+26\. Remove Duplicates from Sorted Array
+
+Easy
+
+Given an integer array `nums` sorted in **non-decreasing order**, remove the duplicates [**in-place**](https://en.wikipedia.org/wiki/In-place_algorithm) such that each unique element appears only **once**. The **relative order** of the elements should be kept the **same**.
+
+Since it is impossible to change the length of the array in some languages, you must instead have the result be placed in the **first part** of the array `nums`. More formally, if there are `k` elements after removing the duplicates, then the first `k` elements of `nums` should hold the final result. It does not matter what you leave beyond the first `k` elements.
+
+Return `k` _after placing the final result in the first_ `k` _slots of_ `nums`.
+
+Do **not** allocate extra space for another array. You must do this by **modifying the input array [in-place](https://en.wikipedia.org/wiki/In-place_algorithm)** with O(1) extra memory.
+
+**Custom Judge:**
+
+The judge will test your solution with the following code:
+
+    int[] nums = [...]; // Input array
+    int[] expectedNums = [...]; // The expected answer with correct length
+
+    int k = removeDuplicates(nums); // Calls your implementation
+
+    assert k == expectedNums.length;
+    for (int i = 0; i < k; i++) {
+        assert nums[i] == expectedNums[i];
+    } 
+
+If all assertions pass, then your solution will be **accepted**.
+
+**Example 1:**
+
+**Input:** nums = [1,1,2]
+
+**Output:** 2, nums = [1,2,\_]
+
+**Explanation:** Your function should return k = 2, with the first two elements of nums being 1 and 2 respectively. It does not matter what you leave beyond the returned k (hence they are underscores). 
+
+**Example 2:**
+
+**Input:** nums = [0,0,1,1,1,2,2,3,3,4]
+
+**Output:** 5, nums = [0,1,2,3,4,\_,\_,\_,\_,\_]
+
+**Explanation:** Your function should return k = 5, with the first five elements of nums being 0, 1, 2, 3, and 4 respectively. It does not matter what you leave beyond the returned k (hence they are underscores). 
+
+**Constraints:**
+
+*   <code>0 <= nums.length <= 3 * 10<sup>4</sup></code>
+*   `-100 <= nums[i] <= 100`
+*   `nums` is sorted in **non-decreasing** order.

LeetCodeNet/G0001_0100/S0027_remove_element/Solution.cs

@@ -0,0 +1,18 @@
+namespace LeetCodeNet.G0001_0100.S0027_remove_element {
+
+// #Easy #Array #Two_Pointers #Top_Interview_150_Array/String
+// #2025_06_30_Time_0_ms_(100.00%)_Space_46.85_MB_(71.67%)
+
+public class Solution {
+    public int RemoveElement(int[] nums, int val) {
+        int i = 0;
+        for (int j = 0; j < nums.Length; j++) {
+            if (nums[j] != val) {
+                nums[i] = nums[j];
+                i++;
+            }
+        }
+        return i;
+    }
+}
+}

LeetCodeNet/G0001_0100/S0027_remove_element/readme.md

@@ -0,0 +1,26 @@
+# 27. Remove Element
+
+Given an integer array `nums` and an integer `val`, remove all occurrences of `val` in `nums` in-place. The order of the elements may be changed. Then return the number of elements in `nums` which are not equal to `val`.
+
+Consider the number of elements in `nums` which are not equal to `val` be `k`, to get accepted, you need to do the following things:
+
+- Change the array `nums` such that the first `k` elements of `nums` contain the elements which are not equal to `val`. The remaining elements of `nums` are not important as well as the size of `nums`.
+- Return `k`.
+
+## Example 1:
+
+**Input:** nums = `[3,2,2,3]`, val = 3
+**Output:** 2, nums = `[2,2,_,_]`
+**Explanation:** Your function should return k = 2, with the first two elements of nums being 2. It does not matter what you leave beyond the returned k (hence they are underscores).
+
+## Example 2:
+
+**Input:** nums = `[0,1,2,2,3,0,4,2]`, val = 2
+**Output:** 5, nums = `[0,1,4,0,3,_,_,_]`
+**Explanation:** Your function should return k = 5, with the first five elements of nums containing 0, 0, 1, 3, and 4. Note that the five elements can be returned in any order. It does not matter what you leave beyond the returned k (hence they are underscores).
+
+**Constraints:**
+
+*   `0 <= nums.length <= 100`
+*   `0 <= nums[i] <= 50`
+*   `0 <= val <= 100`

LeetCodeNet/G0001_0100/S0028_find_the_index_of_the_first_occurrence_in_a_string/Solution.cs

@@ -0,0 +1,23 @@
+namespace LeetCodeNet.G0001_0100.S0028_find_the_index_of_the_first_occurrence_in_a_string {
+
+// #Easy #Top_Interview_Questions #String #Two_Pointers #String_Matching
+// #Programming_Skills_II_Day_1 #Top_Interview_150_Array/String
+// #2025_06_30_Time_0_ms_(100.00%)_Space_39.28_MB_(63.22%)
+
+public class Solution {
+    public int StrStr(string haystack, string needle) {
+        if (string.IsNullOrEmpty(needle)) {
+            return 0;
+        }
+        if (haystack.Length < needle.Length) {
+            return -1;
+        }
+        for (int i = 0; i <= haystack.Length - needle.Length; i++) {
+            if (haystack.Substring(i, needle.Length) == needle) {
+                return i;
+            }
+        }
+        return -1;
+    }
+}
+}