Added tasks 222-274

ThanhNIT · web-flow · commit a2a6d2072a5b · 2025-07-15T18:02:12.000+03:00
diff --git a/LeetCodeNet.Tests/G0201_0300/S0222_count_complete_tree_nodes/SolutionTest.cs b/LeetCodeNet.Tests/G0201_0300/S0222_count_complete_tree_nodes/SolutionTest.cs
@@ -0,0 +1,28 @@
+namespace LeetCodeNet.G0201_0300.S0222_count_complete_tree_nodes {
+
+using LeetCodeNet.Com_github_leetcode;
+using Xunit;
+
+public class SolutionTest {
+    [Fact]
+    public void CountNodes() {
+        var leftNodeLeftNode = new TreeNode(4);
+        var leftNodeRightNode = new TreeNode(5);
+        var leftNode = new TreeNode(2, leftNodeLeftNode, leftNodeRightNode);
+        var rightNodeLeftNode = new TreeNode(6);
+        var rightNode = new TreeNode(3, rightNodeLeftNode, null);
+        var root = new TreeNode(1, leftNode, rightNode);
+        Assert.Equal(6, new Solution().CountNodes(root));
+    }
+
+    [Fact]
+    public void CountNodes2() {
+        Assert.Equal(0, new Solution().CountNodes(null));
+    }
+
+    [Fact]
+    public void CountNodes3() {
+        Assert.Equal(1, new Solution().CountNodes(new TreeNode(1)));
+    }
+}
+}
diff --git a/LeetCodeNet.Tests/G0201_0300/S0224_basic_calculator/SolutionTest.cs b/LeetCodeNet.Tests/G0201_0300/S0224_basic_calculator/SolutionTest.cs
@@ -0,0 +1,21 @@
+namespace LeetCodeNet.G0201_0300.S0224_basic_calculator {
+
+using Xunit;
+
+public class SolutionTest {
+    [Fact]
+    public void Calculate() {
+        Assert.Equal(2, new Solution().Calculate("1 + 1"));
+    }
+
+    [Fact]
+    public void Calculate2() {
+        Assert.Equal(3, new Solution().Calculate(" 2-1 + 2 "));
+    }
+
+    [Fact]
+    public void Calculate3() {
+        Assert.Equal(23, new Solution().Calculate("(1+(4+5+2)-3)+(6+8)"));
+    }
+}
+}
diff --git a/LeetCodeNet.Tests/G0201_0300/S0228_summary_ranges/SolutionTest.cs b/LeetCodeNet.Tests/G0201_0300/S0228_summary_ranges/SolutionTest.cs
@@ -0,0 +1,19 @@
+namespace LeetCodeNet.G0201_0300.S0228_summary_ranges {
+
+using System.Collections.Generic;
+using Xunit;
+
+public class SolutionTest {
+    [Fact]
+    public void SummaryRanges() {
+        var expected = new List<string> { "0->2", "4->5", "7" };
+        Assert.Equal(expected, new Solution().SummaryRanges(new[] { 0, 1, 2, 4, 5, 7 }));
+    }
+
+    [Fact]
+    public void SummaryRanges2() {
+        var expected = new List<string> { "0", "2->4", "6", "8->9" };
+        Assert.Equal(expected, new Solution().SummaryRanges(new[] { 0, 2, 3, 4, 6, 8, 9 }));
+    }
+}
+}
diff --git a/LeetCodeNet.Tests/G0201_0300/S0242_valid_anagram/SolutionTest.cs b/LeetCodeNet.Tests/G0201_0300/S0242_valid_anagram/SolutionTest.cs
@@ -0,0 +1,16 @@
+namespace LeetCodeNet.G0201_0300.S0242_valid_anagram {
+
+using Xunit;
+
+public class SolutionTest {
+    [Fact]
+    public void IsAnagram() {
+        Assert.True(new Solution().IsAnagram("anagram", "nagaram"));
+    }
+
+    [Fact]
+    public void IsAnagram2() {
+        Assert.False(new Solution().IsAnagram("rat", "car"));
+    }
+}
+}
diff --git a/LeetCodeNet.Tests/G0201_0300/S0274_h_index/SolutionTest.cs b/LeetCodeNet.Tests/G0201_0300/S0274_h_index/SolutionTest.cs
@@ -0,0 +1,16 @@
+namespace LeetCodeNet.G0201_0300.S0274_h_index {
+
+using Xunit;
+
+public class SolutionTest {
+    [Fact]
+    public void HIndex() {
+        Assert.Equal(3, new Solution().HIndex(new[] { 3, 0, 6, 1, 5 }));
+    }
+
+    [Fact]
+    public void HIndex2() {
+        Assert.Equal(1, new Solution().HIndex(new[] { 1, 3, 1 }));
+    }
+}
+}
diff --git a/LeetCodeNet/G0201_0300/S0222_count_complete_tree_nodes/Solution.cs b/LeetCodeNet/G0201_0300/S0222_count_complete_tree_nodes/Solution.cs
@@ -0,0 +1,49 @@
+namespace LeetCodeNet.G0201_0300.S0222_count_complete_tree_nodes {
+
+// #Easy #Depth_First_Search #Tree #Binary_Search #Binary_Tree #Binary_Search_II_Day_10
+// #Top_Interview_150_Binary_Tree_General #2025_07_15_Time_0_ms_(100.00%)_Space_50.72_MB_(19.76%)
+
+using LeetCodeNet.Com_github_leetcode;
+
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public int val;
+ *     public TreeNode left;
+ *     public TreeNode right;
+ *     public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+public class Solution {
+    public int CountNodes(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+        int leftHeight = LeftHeight(root);
+        int rightHeight = RightHeight(root);
+        if (leftHeight == rightHeight) {
+            return (1 << leftHeight) - 1;
+        } else {
+            return 1 + CountNodes(root.left) + CountNodes(root.right);
+        }
+    }
+
+    private int LeftHeight(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+        return 1 + LeftHeight(root.left);
+    }
+
+    private int RightHeight(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+        return 1 + RightHeight(root.right);
+    }
+}
+}
diff --git a/LeetCodeNet/G0201_0300/S0222_count_complete_tree_nodes/readme.md b/LeetCodeNet/G0201_0300/S0222_count_complete_tree_nodes/readme.md
@@ -0,0 +1,35 @@
+222\. Count Complete Tree Nodes
+
+Medium
+
+Given the `root` of a **complete** binary tree, return the number of the nodes in the tree.
+
+According to **[Wikipedia](http://en.wikipedia.org/wiki/Binary_tree#Types_of_binary_trees)**, every level, except possibly the last, is completely filled in a complete binary tree, and all nodes in the last level are as far left as possible. It can have between `1` and <code>2<sup>h</sup></code> nodes inclusive at the last level `h`.
+
+Design an algorithm that runs in less than `O(n)` time complexity.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/01/14/complete.jpg)
+
+**Input:** root = [1,2,3,4,5,6]
+
+**Output:** 6 
+
+**Example 2:**
+
+**Input:** root = []
+
+**Output:** 0 
+
+**Example 3:**
+
+**Input:** root = [1]
+
+**Output:** 1 
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range <code>[0, 5 * 10<sup>4</sup>]</code>.
+*   <code>0 <= Node.val <= 5 * 10<sup>4</sup></code>
+*   The tree is guaranteed to be **complete**.
diff --git a/LeetCodeNet/G0201_0300/S0224_basic_calculator/Solution.cs b/LeetCodeNet/G0201_0300/S0224_basic_calculator/Solution.cs
@@ -0,0 +1,34 @@
+namespace LeetCodeNet.G0201_0300.S0224_basic_calculator {
+
+// #Hard #String #Math #Stack #Recursion #Top_Interview_150_Stack
+// #2025_07_15_Time_3_ms_(96.26%)_Space_42.26_MB_(95.95%)
+
+public class Solution {
+    public int Calculate(string s) {
+        Stack<int> st = new Stack<int>();
+        int ans = 0;
+        int sum = 0;
+        int sign = 1;
+        st.Push(1);
+        foreach (char ch in s) {
+            if (ch >= '0' && ch <= '9') {
+                sum = sum * 10 + ch - '0';
+            } else if (ch == '(') {
+                st.Push(sign);
+            } else if (ch == ')') {
+                st.Pop();
+            } else if (ch == '-' || ch == '+') {
+                ans += sum * sign;
+                if (ch == '-') {
+                    sign = -1 * st.Peek();
+                } else {
+                    sign = st.Peek();
+                }
+                sum = 0;
+            }
+        }
+        ans += sum * sign;
+        return ans;
+    }
+}
+}
diff --git a/LeetCodeNet/G0201_0300/S0224_basic_calculator/readme.md b/LeetCodeNet/G0201_0300/S0224_basic_calculator/readme.md
@@ -0,0 +1,35 @@
+224\. Basic Calculator
+
+Hard
+
+Given a string `s` representing a valid expression, implement a basic calculator to evaluate it, and return _the result of the evaluation_.
+
+**Note:** You are **not** allowed to use any built-in function which evaluates strings as mathematical expressions, such as `eval()`.
+
+**Example 1:**
+
+**Input:** s = "1 + 1"
+
+**Output:** 2 
+
+**Example 2:**
+
+**Input:** s = " 2-1 + 2 "
+
+**Output:** 3 
+
+**Example 3:**
+
+**Input:** s = "(1+(4+5+2)-3)+(6+8)"
+
+**Output:** 23 
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 3 * 10<sup>5</sup></code>
+*   `s` consists of digits, `'+'`, `'-'`, `'('`, `')'`, and `' '`.
+*   `s` represents a valid expression.
+*   `'+'` is **not** used as a unary operation (i.e., `"+1"` and `"+(2 + 3)"` is invalid).
+*   `'-'` could be used as a unary operation (i.e., `"-1"` and `"-(2 + 3)"` is valid).
+*   There will be no two consecutive operators in the input.
+*   Every number and running calculation will fit in a signed 32-bit integer.
diff --git a/LeetCodeNet/G0201_0300/S0228_summary_ranges/Solution.cs b/LeetCodeNet/G0201_0300/S0228_summary_ranges/Solution.cs
@@ -0,0 +1,30 @@
+namespace LeetCodeNet.G0201_0300.S0228_summary_ranges {
+
+// #Easy #Array #Top_Interview_150_Intervals #2025_07_15_Time_0_ms_(100.00%)_Space_47.48_MB_(50.51%)
+
+public class Solution {
+    public IList<string> SummaryRanges(int[] nums) {
+        List<string> result = new List<string>();
+        if (nums.Length == 0) {
+            return result;
+        }
+        int startIndex = 0;
+        for (int i = 1; i < nums.Length; ++i) {
+            if (nums[i] != nums[i - 1] + 1) {
+                if (startIndex != i - 1) {
+                    result.Add(nums[startIndex] + "->" + (nums[i - 1]).ToString());
+                } else {
+                    result.Add(nums[startIndex].ToString());
+                }
+                startIndex = i;
+            }
+        }
+        if (startIndex != nums.Length - 1) {
+            result.Add(nums[startIndex] + "->" + (nums[nums.Length - 1]).ToString());
+        } else {
+            result.Add(nums[startIndex].ToString());
+        }
+        return result;
+    }
+}
+}
diff --git a/LeetCodeNet/G0201_0300/S0228_summary_ranges/readme.md b/LeetCodeNet/G0201_0300/S0228_summary_ranges/readme.md
@@ -0,0 +1,53 @@
+228\. Summary Ranges
+
+Easy
+
+You are given a **sorted unique** integer array `nums`.
+
+Return _the **smallest sorted** list of ranges that **cover all the numbers in the array exactly**_. That is, each element of `nums` is covered by exactly one of the ranges, and there is no integer `x` such that `x` is in one of the ranges but not in `nums`.
+
+Each range `[a,b]` in the list should be output as:
+
+*   `"a->b"` if `a != b`
+*   `"a"` if `a == b`
+
+**Example 1:**
+
+**Input:** nums = [0,1,2,4,5,7]
+
+**Output:** ["0->2","4->5","7"]
+
+**Explanation:** The ranges are: [0,2] --> "0->2" [4,5] --> "4->5" [7,7] --> "7" 
+
+**Example 2:**
+
+**Input:** nums = [0,2,3,4,6,8,9]
+
+**Output:** ["0","2->4","6","8->9"]
+
+**Explanation:** The ranges are: [0,0] --> "0" [2,4] --> "2->4" [6,6] --> "6" [8,9] --> "8->9" 
+
+**Example 3:**
+
+**Input:** nums = []
+
+**Output:** [] 
+
+**Example 4:**
+
+**Input:** nums = [-1]
+
+**Output:** ["-1"] 
+
+**Example 5:**
+
+**Input:** nums = [0]
+
+**Output:** ["0"] 
+
+**Constraints:**
+
+*   `0 <= nums.length <= 20`
+*   <code>-2<sup>31</sup> <= nums[i] <= 2<sup>31</sup> - 1</code>
+*   All the values of `nums` are **unique**.
+*   `nums` is sorted in ascending order.
diff --git a/LeetCodeNet/G0201_0300/S0242_valid_anagram/Solution.cs b/LeetCodeNet/G0201_0300/S0242_valid_anagram/Solution.cs
@@ -0,0 +1,25 @@
+namespace LeetCodeNet.G0201_0300.S0242_valid_anagram {
+
+// #Easy #String #Hash_Table #Sorting #Data_Structure_I_Day_6_String
+// #Programming_Skills_I_Day_11_Containers_and_Libraries #Udemy_Strings #Top_Interview_150_Hashmap
+// #2025_07_15_Time_0_ms_(100.00%)_Space_43.94_MB_(45.52%)
+
+public class Solution {
+    public bool IsAnagram(string s, string t) {
+        if (s.Length != t.Length) {
+            return false;
+        }
+        int[] charFreqMap = new int[26];
+        foreach (char c in s) {
+            charFreqMap[c - 'a']++;
+        }
+        foreach (char c in t) {
+            if (charFreqMap[c - 'a'] == 0) {
+                return false;
+            }
+            charFreqMap[c - 'a']--;
+        }
+        return true;
+    }
+}
+}
diff --git a/LeetCodeNet/G0201_0300/S0242_valid_anagram/readme.md b/LeetCodeNet/G0201_0300/S0242_valid_anagram/readme.md
diff --git a/LeetCodeNet/G0201_0300/S0274_h_index/Solution.cs b/LeetCodeNet/G0201_0300/S0274_h_index/Solution.cs
diff --git a/LeetCodeNet/G0201_0300/S0274_h_index/readme.md b/LeetCodeNet/G0201_0300/S0274_h_index/readme.md
