Added tasks 222-383

Author: javadev

LeetCodeNet/G0201_0300/S0222_count_complete_tree_nodes/readme.md

@@ -0,0 +1,86 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Net/LeetCode-in-Net?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net)
+[![](https://img.shields.io/github/forks/LeetCode-in-Net/LeetCode-in-Net?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net/fork)
+
+## 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**.
+
+## Solution
+
+```csharp
+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);
+    }
+}
+```

LeetCodeNet/G0201_0300/S0224_basic_calculator/readme.md

@@ -0,0 +1,71 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Net/LeetCode-in-Net?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net)
+[![](https://img.shields.io/github/forks/LeetCode-in-Net/LeetCode-in-Net?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net/fork)
+
+## 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.
+
+## Solution
+
+```csharp
+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;
+    }
+}
+```

LeetCodeNet/G0201_0300/S0228_summary_ranges/readme.md

@@ -0,0 +1,86 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Net/LeetCode-in-Net?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net)
+[![](https://img.shields.io/github/forks/LeetCode-in-Net/LeetCode-in-Net?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net/fork)
+
+## 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.
+
+## Solution
+
+```csharp
+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;
+    }
+}
+```

LeetCodeNet/G0201_0300/S0242_valid_anagram/readme.md

@@ -0,0 +1,50 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Net/LeetCode-in-Net?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net)
+[![](https://img.shields.io/github/forks/LeetCode-in-Net/LeetCode-in-Net?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net/fork)
+
+## 242\. Valid Anagram
+
+Easy
+
+Given two strings `s` and `t`, return `true` _if_ `t` _is an anagram of_ `s`_, and_ `false` _otherwise_.
+
+**Example 1:**
+
+**Input:** s = "anagram", t = "nagaram"
+
+**Output:** true 
+
+**Example 2:**
+
+**Input:** s = "rat", t = "car"
+
+**Output:** false 
+
+**Constraints:**
+
+*   <code>1 <= s.length, t.length <= 5 * 10<sup>4</sup></code>
+*   `s` and `t` consist of lowercase English letters.
+
+**Follow up:** What if the inputs contain Unicode characters? How would you adapt your solution to such a case?
+
+## Solution
+
+```csharp
+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;
+    }
+}
+```

LeetCodeNet/G0201_0300/S0274_h_index/readme.md

@@ -0,0 +1,57 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Net/LeetCode-in-Net?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net)
+[![](https://img.shields.io/github/forks/LeetCode-in-Net/LeetCode-in-Net?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net/fork)
+
+## 274\. H-Index
+
+Medium
+
+Given an array of integers `citations` where `citations[i]` is the number of citations a researcher received for their <code>i<sup>th</sup></code> paper, return compute the researcher's `h`**\-index**.
+
+According to the [definition of h-index on Wikipedia](https://en.wikipedia.org/wiki/H-index): A scientist has an index `h` if `h` of their `n` papers have at least `h` citations each, and the other `n − h` papers have no more than `h` citations each.
+
+If there are several possible values for `h`, the maximum one is taken as the `h`**\-index**.
+
+**Example 1:**
+
+**Input:** citations = [3,0,6,1,5]
+
+**Output:** 3
+
+**Explanation:**
+
+    [3,0,6,1,5] means the researcher has 5 papers in total and each of them had received 3, 0, 6, 1, 5 citations respectively.
+    Since the researcher has 3 papers with at least 3 citations each and the remaining two with no more than 3 citations each, their h-index is 3. 
+
+**Example 2:**
+
+**Input:** citations = [1,3,1]
+
+**Output:** 1 
+
+**Constraints:**
+
+*   `n == citations.length`
+*   `1 <= n <= 5000`
+*   `0 <= citations[i] <= 1000`
+
+## Solution
+
+```csharp
+public class Solution {
+    public int HIndex(int[] citations) {
+        int len = citations.Length;
+        int[] freqArray = new int[len + 1];
+        foreach (int citation in citations) {
+            freqArray[Math.Min(citation, len)]++;
+        }
+        int totalSoFar = 0;
+        for (int k = len; k >= 0; k--) {
+            totalSoFar += freqArray[k];
+            if (totalSoFar >= k) {
+                return k;
+            }
+        }
+        return 0;
+    }
+}
+```