Added tasks-137-162

ThanhNIT · web-flow · commit 11e9d286d2c8 · 2025-07-12T15:56:57.000+03:00
diff --git a/LeetCodeNet.Tests/G0101_0200/S0137_single_number_ii/SolutionTest.cs b/LeetCodeNet.Tests/G0101_0200/S0137_single_number_ii/SolutionTest.cs
@@ -0,0 +1,16 @@
+namespace LeetCodeNet.G0101_0200.S0137_single_number_ii {
+
+    using Xunit;
+
+    public class SolutionTest {
+        [Fact]
+        public void SingleNumber() {
+            Assert.Equal(3, new Solution().SingleNumber(new int[] {2, 2, 3, 2}));
+        }
+
+        [Fact]
+        public void SingleNumber2() {
+            Assert.Equal(99, new Solution().SingleNumber(new int[] {0, 1, 0, 1, 0, 1, 99}));
+        }
+    }
+}
diff --git a/LeetCodeNet.Tests/G0101_0200/S0149_max_points_on_a_line/SolutionTest.cs b/LeetCodeNet.Tests/G0101_0200/S0149_max_points_on_a_line/SolutionTest.cs
@@ -0,0 +1,18 @@
+namespace LeetCodeNet.G0101_0200.S0149_max_points_on_a_line {
+
+    using Xunit;
+
+    public class SolutionTest {
+        [Fact]
+        public void MaxPoints() {
+            int[][] input = new int[][] {new int[] {1, 1}, new int[] {2, 2}, new int[] {3, 3}};
+            Assert.Equal(3, new Solution().MaxPoints(input));
+        }
+
+        [Fact]
+        public void MaxPoints2() {
+            int[][] input = new int[][] {new int[] {1, 1}, new int[] {3, 2}, new int[] {5, 3}, new int[] {4, 1}, new int[] {2, 3}, new int[] {1, 4}};
+            Assert.Equal(4, new Solution().MaxPoints(input));
+        }
+    }
+}
diff --git a/LeetCodeNet.Tests/G0101_0200/S0150_evaluate_reverse_polish_notation/SolutionTest.cs b/LeetCodeNet.Tests/G0101_0200/S0150_evaluate_reverse_polish_notation/SolutionTest.cs
@@ -0,0 +1,23 @@
+namespace LeetCodeNet.G0101_0200.S0150_evaluate_reverse_polish_notation {
+
+    using Xunit;
+
+    public class SolutionTest {
+        [Fact]
+        public void EvalRPN() {
+            Assert.Equal(9, new Solution().EvalRPN(new string[] {"2", "1", "+", "3", "*"}));
+        }
+
+        [Fact]
+        public void EvalRPN2() {
+            Assert.Equal(6, new Solution().EvalRPN(new string[] {"4", "13", "5", "/", "+"}));
+        }
+
+        [Fact]
+        public void EvalRPN3() {
+            Assert.Equal(22, new Solution().EvalRPN(new string[] {
+                "10", "6", "9", "3", "+", "-11", "*", "/", "*", "17", "+", "5", "+"
+            }));
+        }
+    }
+}
diff --git a/LeetCodeNet.Tests/G0101_0200/S0151_reverse_words_in_a_string/SolutionTest.cs b/LeetCodeNet.Tests/G0101_0200/S0151_reverse_words_in_a_string/SolutionTest.cs
@@ -0,0 +1,21 @@
+namespace LeetCodeNet.G0101_0200.S0151_reverse_words_in_a_string {
+
+    using Xunit;
+
+    public class SolutionTest {
+        [Fact]
+        public void ReverseWords() {
+            Assert.Equal("blue is sky the", new Solution().ReverseWords("the sky is blue"));
+        }
+
+        [Fact]
+        public void ReverseWords2() {
+            Assert.Equal("world hello", new Solution().ReverseWords("  hello world  "));
+        }
+
+        [Fact]
+        public void ReverseWords3() {
+            Assert.Equal("example good a", new Solution().ReverseWords("a good   example"));
+        }
+    }
+}
diff --git a/LeetCodeNet.Tests/G0101_0200/S0162_find_peak_element/SolutionTest.cs b/LeetCodeNet.Tests/G0101_0200/S0162_find_peak_element/SolutionTest.cs
@@ -0,0 +1,16 @@
+namespace LeetCodeNet.G0101_0200.S0162_find_peak_element {
+
+    using Xunit;
+
+    public class SolutionTest {
+        [Fact]
+        public void FindPeakElement() {
+            Assert.Equal(2, new Solution().FindPeakElement(new int[] {1, 2, 3, 1}));
+        }
+
+        [Fact]
+        public void FindPeakElement2() {
+            Assert.Equal(5, new Solution().FindPeakElement(new int[] {1, 2, 1, 3, 5, 6, 4}));
+        }
+    }
+}
diff --git a/LeetCodeNet/G0101_0200/S0137_single_number_ii/Solution.cs b/LeetCodeNet/G0101_0200/S0137_single_number_ii/Solution.cs
@@ -0,0 +1,17 @@
+namespace LeetCodeNet.G0101_0200.S0137_single_number_ii {
+
+// #Medium #Array #Bit_Manipulation #Top_Interview_150_Bit_Manipulation
+// #2025_07_12_Time_0_ms_(100.00%)_Space_43.58_MB_(81.90%)
+
+public class Solution {
+    public int SingleNumber(int[] nums) {
+        int ones = 0;
+        int twos = 0;
+        foreach (int num in nums) {
+            ones = (ones ^ num) & (~twos);
+            twos = (twos ^ num) & (~ones);
+        }
+        return ones;
+    }
+}
+}
diff --git a/LeetCodeNet/G0101_0200/S0137_single_number_ii/readme.md b/LeetCodeNet/G0101_0200/S0137_single_number_ii/readme.md
@@ -0,0 +1,25 @@
+137\. Single Number II
+
+Medium
+
+Given an integer array `nums` where every element appears **three times** except for one, which appears **exactly once**. _Find the single element and return it_.
+
+You must implement a solution with a linear runtime complexity and use only constant extra space.
+
+**Example 1:**
+
+**Input:** nums = [2,2,3,2]
+
+**Output:** 3 
+
+**Example 2:**
+
+**Input:** nums = [0,1,0,1,0,1,99]
+
+**Output:** 99 
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 3 * 10<sup>4</sup></code>
+*   <code>-2<sup>31</sup> <= nums[i] <= 2<sup>31</sup> - 1</code>
+*   Each element in `nums` appears exactly **three times** except for one element which appears **once**.
diff --git a/LeetCodeNet/G0101_0200/S0149_max_points_on_a_line/Solution.cs b/LeetCodeNet/G0101_0200/S0149_max_points_on_a_line/Solution.cs
@@ -0,0 +1,29 @@
+namespace LeetCodeNet.G0101_0200.S0149_max_points_on_a_line {
+
+// #Hard #Top_Interview_Questions #Array #Hash_Table #Math #Geometry #Algorithm_II_Day_21_Others
+// #Top_Interview_150_Math #2025_07_12_Time_5_ms_(100.00%)_Space_41.59_MB_(98.57%)
+
+public class Solution {
+    public int MaxPoints(int[][] points) {
+        if (points.Length < 2) {
+            return points.Length;
+        }
+        int max = 0;
+        for (int i = 0; i < points.Length; i++) {
+            for (int j = i + 1; j < points.Length; j++) {
+                int x = points[j][0] - points[i][0];
+                int y = points[j][1] - points[i][1];
+                int c = x * points[j][1] - y * points[j][0];
+                int count = 2;
+                for (int k = j + 1; k < points.Length; k++) {
+                    if (c == x * points[k][1] - y * points[k][0]) {
+                        count++;
+                    }
+                }
+                max = System.Math.Max(count, max);
+            }
+        }
+        return max;
+    }
+}
+}
diff --git a/LeetCodeNet/G0101_0200/S0149_max_points_on_a_line/readme.md b/LeetCodeNet/G0101_0200/S0149_max_points_on_a_line/readme.md
@@ -0,0 +1,28 @@
+149\. Max Points on a Line
+
+Hard
+
+Given an array of `points` where <code>points[i] = [x<sub>i</sub>, y<sub>i</sub>]</code> represents a point on the **X-Y** plane, return _the maximum number of points that lie on the same straight line_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/02/25/plane1.jpg)
+
+**Input:** points = [[1,1],[2,2],[3,3]]
+
+**Output:** 3 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/02/25/plane2.jpg)
+
+**Input:** points = [[1,1],[3,2],[5,3],[4,1],[2,3],[1,4]]
+
+**Output:** 4 
+
+**Constraints:**
+
+*   `1 <= points.length <= 300`
+*   `points[i].length == 2`
+*   <code>-10<sup>4</sup> <= x<sub>i</sub>, y<sub>i</sub> <= 10<sup>4</sup></code>
+*   All the `points` are **unique**.
diff --git a/LeetCodeNet/G0101_0200/S0150_evaluate_reverse_polish_notation/Solution.cs b/LeetCodeNet/G0101_0200/S0150_evaluate_reverse_polish_notation/Solution.cs
@@ -0,0 +1,32 @@
+namespace LeetCodeNet.G0101_0200.S0150_evaluate_reverse_polish_notation {
+
+// #Medium #Top_Interview_Questions #Array #Math #Stack #Programming_Skills_II_Day_3
+// #Top_Interview_150_Stack #2025_07_12_Time_11_ms_(77.03%)_Space_44.57_MB_(49.39%)
+
+using System.Collections.Generic;
+
+public class Solution {
+    public int EvalRPN(string[] tokens) {
+        var st = new Stack<int>();
+        foreach (string token in tokens) {
+            if (!char.IsDigit(token[token.Length - 1])) {
+                int second = st.Pop();
+                int first = st.Pop();
+                st.Push(Eval(first, second, token));
+            } else {
+                st.Push(int.Parse(token));
+            }
+        }
+        return st.Pop();
+    }
+
+    private int Eval(int first, int second, string op) {
+        return op switch {
+            "+" => first + second,
+            "-" => first - second,
+            "*" => first * second,
+            _ => first / second
+        };
+    }
+}
+}
diff --git a/LeetCodeNet/G0101_0200/S0150_evaluate_reverse_polish_notation/readme.md b/LeetCodeNet/G0101_0200/S0150_evaluate_reverse_polish_notation/readme.md
@@ -0,0 +1,48 @@
+150\. Evaluate Reverse Polish Notation
+
+Medium
+
+Evaluate the value of an arithmetic expression in [Reverse Polish Notation](http://en.wikipedia.org/wiki/Reverse_Polish_notation).
+
+Valid operators are `+`, `-`, `*`, and `/`. Each operand may be an integer or another expression.
+
+**Note** that division between two integers should truncate toward zero.
+
+It is guaranteed that the given RPN expression is always valid. That means the expression would always evaluate to a result, and there will not be any division by zero operation.
+
+**Example 1:**
+
+**Input:** tokens = ["2","1","+","3","\*"]
+
+**Output:** 9
+
+**Explanation:** ((2 + 1) \* 3) = 9 
+
+**Example 2:**
+
+**Input:** tokens = ["4","13","5","/","+"]
+
+**Output:** 6
+
+**Explanation:** (4 + (13 / 5)) = 6 
+
+**Example 3:**
+
+**Input:** tokens = ["10","6","9","3","+","-11","\*","/","\*","17","+","5","+"]
+
+**Output:** 22
+
+**Explanation:**
+
+    ((10 \* (6 / ((9 + 3) \* -11))) + 17) + 5
+    = ((10 \* (6 / (12 \* -11))) + 17) + 5
+    = ((10 \* (6 / -132)) + 17) + 5
+    = ((10 \* 0) + 17) + 5
+    = (0 + 17) + 5
+    = 17 + 5
+    = 22 
+
+**Constraints:**
+
+*   <code>1 <= tokens.length <= 10<sup>4</sup></code>
+*   `tokens[i]` is either an operator: `"+"`, `"-"`, `"*"`, or `"/"`, or an integer in the range `[-200, 200]`.
diff --git a/LeetCodeNet/G0101_0200/S0151_reverse_words_in_a_string/Solution.cs b/LeetCodeNet/G0101_0200/S0151_reverse_words_in_a_string/Solution.cs
@@ -0,0 +1,28 @@
+namespace LeetCodeNet.G0101_0200.S0151_reverse_words_in_a_string {
+
+// #Medium #String #Two_Pointers #LeetCode_75_Array/String #Udemy_Strings
+// #Top_Interview_150_Array/String #2025_07_12_Time_2_ms_(67.44%)_Space_41.52_MB_(95.70%)
+
+using System.Text;
+
+public class Solution {
+    public string ReverseWords(string s) {
+        var sb = new StringBuilder();
+        int i = s.Length - 1;
+        while (i >= 0) {
+            if (s[i] == ' ') {
+                i--;
+                continue;
+            }
+            int start = s.LastIndexOf(' ', i);
+            sb.Append(' ');
+            sb.Append(s, start + 1, i - start);
+            i = start - 1;
+        }
+        if (sb.Length > 0) {
+            sb.Remove(0, 1);
+        }
+        return sb.ToString();
+    }
+}
+}
diff --git a/LeetCodeNet/G0101_0200/S0151_reverse_words_in_a_string/readme.md b/LeetCodeNet/G0101_0200/S0151_reverse_words_in_a_string/readme.md
@@ -0,0 +1,53 @@
+151\. Reverse Words in a String
+
+Medium
+
+Given an input string `s`, reverse the order of the **words**.
+
+A **word** is defined as a sequence of non-space characters. The **words** in `s` will be separated by at least one space.
+
+Return _a string of the words in reverse order concatenated by a single space._
+
+**Note** that `s` may contain leading or trailing spaces or multiple spaces between two words. The returned string should only have a single space separating the words. Do not include any extra spaces.
+
+**Example 1:**
+
+**Input:** s = "the sky is blue"
+
+**Output:** "blue is sky the" 
+
+**Example 2:**
+
+**Input:** s = " hello world "
+
+**Output:** "world hello"
+
+**Explanation:** Your reversed string should not contain leading or trailing spaces. 
+
+**Example 3:**
+
+**Input:** s = "a good example"
+
+**Output:** "example good a"
+
+**Explanation:** You need to reduce multiple spaces between two words to a single space in the reversed string. 
+
+**Example 4:**
+
+**Input:** s = " Bob Loves Alice "
+
+**Output:** "Alice Loves Bob" 
+
+**Example 5:**
+
+**Input:** s = "Alice does not even like bob"
+
+**Output:** "bob like even not does Alice" 
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>4</sup></code>
+*   `s` contains English letters (upper-case and lower-case), digits, and spaces `' '`.
+*   There is **at least one** word in `s`.
+
+**Follow-up:** If the string data type is mutable in your language, can you solve it **in-place** with `O(1)` extra space?
diff --git a/LeetCodeNet/G0101_0200/S0162_find_peak_element/Solution.cs b/LeetCodeNet/G0101_0200/S0162_find_peak_element/Solution.cs
@@ -0,0 +1,22 @@
+namespace LeetCodeNet.G0101_0200.S0162_find_peak_element {
+
+// #Medium #Top_Interview_Questions #Array #Binary_Search #LeetCode_75_Binary_Search
+// #Algorithm_II_Day_2_Binary_Search #Binary_Search_II_Day_12 #Top_Interview_150_Binary_Search
+// #2025_07_12_Time_0_ms_(100.00%)_Space_42.58_MB_(54.62%)
+
+public class Solution {
+    public int FindPeakElement(int[] nums) {
+        int start = 0;
+        int end = nums.Length - 1;
+        while (start < end) {
+            int mid = start + ((end - start) / 2);
+            if (nums[mid + 1] > nums[mid]) {
+                start = mid + 1;
+            } else {
+                end = mid;
+            }
+        }
+        return start;
+    }
+}
+}
diff --git a/LeetCodeNet/G0101_0200/S0162_find_peak_element/readme.md b/LeetCodeNet/G0101_0200/S0162_find_peak_element/readme.md
