Added tasks 167-190

Author: ThanhNIT

LeetCodeNet.Tests/G0101_0200/S0167_two_sum_ii_input_array_is_sorted/SolutionTest.cs

@@ -0,0 +1,21 @@
+namespace LeetCodeNet.G0101_0200.S0167_two_sum_ii_input_array_is_sorted {
+
+using Xunit;
+
+public class SolutionTest {
+    [Fact]
+    public void TwoSum() {
+        Assert.Equal(new int[] {1, 2}, new Solution().TwoSum(new int[] {2, 7, 11, 15}, 9));
+    }
+
+    [Fact]
+    public void TwoSum2() {
+        Assert.Equal(new int[] {1, 3}, new Solution().TwoSum(new int[] {2, 3, 4}, 6));
+    }
+
+    [Fact]
+    public void TwoSum3() {
+        Assert.Equal(new int[] {1, 2}, new Solution().TwoSum(new int[] {-1, 0}, -1));
+    }
+}
+}

LeetCodeNet.Tests/G0101_0200/S0172_factorial_trailing_zeroes/SolutionTest.cs

@@ -0,0 +1,21 @@
+namespace LeetCodeNet.G0101_0200.S0172_factorial_trailing_zeroes {
+
+using Xunit;
+
+public class SolutionTest {
+    [Fact]
+    public void TrailingZeroes() {
+        Assert.Equal(0, new Solution().TrailingZeroes(3));
+    }
+
+    [Fact]
+    public void TrailingZeroes2() {
+        Assert.Equal(1, new Solution().TrailingZeroes(5));
+    }
+
+    [Fact]
+    public void TrailingZeroes3() {
+        Assert.Equal(0, new Solution().TrailingZeroes(0));
+    }
+}
+}

LeetCodeNet.Tests/G0101_0200/S0173_binary_search_tree_iterator/BSTIteratorTest.cs

@@ -0,0 +1,25 @@
+namespace LeetCodeNet.G0101_0200.S0173_binary_search_tree_iterator {
+
+using Xunit;
+using System.Collections.Generic;
+using LeetCodeNet.Com_github_leetcode;
+
+public class BSTIteratorTest {
+    [Fact]
+    public void IteratorBST() {
+        var left = new TreeNode(3);
+        var right = new TreeNode(15, new TreeNode(9), new TreeNode(20));
+        var root = new TreeNode(7, left, right);
+        var iterator = new BSTIterator(root);
+        Assert.Equal(3, iterator.Next());
+        Assert.Equal(7, iterator.Next());
+        Assert.True(iterator.HasNext());
+        Assert.Equal(9, iterator.Next());
+        Assert.True(iterator.HasNext());
+        Assert.Equal(15, iterator.Next());
+        Assert.True(iterator.HasNext());
+        Assert.Equal(20, iterator.Next());
+        Assert.False(iterator.HasNext());
+    }
+}
+}

LeetCodeNet.Tests/G0101_0200/S0188_best_time_to_buy_and_sell_stock_iv/SolutionTest.cs

@@ -0,0 +1,16 @@
+namespace LeetCodeNet.G0101_0200.S0188_best_time_to_buy_and_sell_stock_iv {
+
+using Xunit;
+
+public class SolutionTest {
+    [Fact]
+    public void MaxProfit() {
+        Assert.Equal(2, new Solution().MaxProfit(2, new int[] {2, 4, 1}));
+    }
+
+    [Fact]
+    public void MaxProfit2() {
+        Assert.Equal(7, new Solution().MaxProfit(2, new int[] {3, 2, 6, 5, 0, 3}));
+    }
+}
+}

LeetCodeNet.Tests/G0101_0200/S0190_reverse_bits/SolutionTest.cs

@@ -0,0 +1,16 @@
+namespace LeetCodeNet.G0101_0200.S0190_reverse_bits {
+
+using Xunit;
+
+public class SolutionTest {
+    [Fact]
+    public void reverseBits() {
+        Assert.Equal(0b00111001011110000010100101000000u, new Solution().reverseBits(0b00000010100101000001111010011100u));
+    }
+
+    [Fact]
+    public void reverseBits2() {
+        Assert.Equal(0b10111111111111111111111111111111u, new Solution().reverseBits(0b11111111111111111111111111111101u));
+    }
+}
+}

LeetCodeNet/G0101_0200/S0167_two_sum_ii_input_array_is_sorted/Solution.cs

@@ -0,0 +1,27 @@
+namespace LeetCodeNet.G0101_0200.S0167_two_sum_ii_input_array_is_sorted {
+
+// #Medium #Array #Binary_Search #Two_Pointers #Algorithm_I_Day_3_Two_Pointers
+// #Binary_Search_I_Day_7 #Top_Interview_150_Two_Pointers
+// #2025_07_13_Time_0_ms_(100.00%)_Space_50.79_MB_(76.45%)
+
+public class Solution {
+    public int[] TwoSum(int[] numbers, int target) {
+        int[] res = new int[2];
+        int i = 0;
+        int j = numbers.Length - 1;
+        while (i < j) {
+            int sum = numbers[i] + numbers[j];
+            if (sum == target) {
+                res[0] = i + 1;
+                res[1] = j + 1;
+                return res;
+            } else if (sum < target) {
+                i++;
+            } else {
+                j--;
+            }
+        }
+        return res;
+    }
+}
+}

LeetCodeNet/G0101_0200/S0167_two_sum_ii_input_array_is_sorted/readme.md

@@ -0,0 +1,41 @@
+167\. Two Sum II - Input Array Is Sorted
+
+Easy
+
+Given a **1-indexed** array of integers `numbers` that is already **_sorted in non-decreasing order_**, find two numbers such that they add up to a specific `target` number. Let these two numbers be <code>numbers[index<sub>1</sub>]</code> and <code>numbers[index<sub>2</sub>]</code> where <code>1 <= index<sub>1</sub> < index<sub>2</sub> <= numbers.length</code>.
+
+Return _the indices of the two numbers,_ <code>index<sub>1</sub></code> _and_ <code>index<sub>2</sub></code>_, **added by one** as an integer array_ <code>[index<sub>1</sub>, index<sub>2</sub>]</code> _of length 2._
+
+The tests are generated such that there is **exactly one solution**. You **may not** use the same element twice.
+
+**Example 1:**
+
+**Input:** numbers = [2,7,11,15], target = 9
+
+**Output:** [1,2]
+
+**Explanation:** The sum of 2 and 7 is 9. Therefore, index<sub>1</sub> = 1, index<sub>2</sub> = 2. We return [1, 2]. 
+
+**Example 2:**
+
+**Input:** numbers = [2,3,4], target = 6
+
+**Output:** [1,3]
+
+**Explanation:** The sum of 2 and 4 is 6. Therefore index<sub>1</sub> = 1, index<sub>2</sub> = 3. We return [1, 3]. 
+
+**Example 3:**
+
+**Input:** numbers = [\-1,0], target = -1
+
+**Output:** [1,2]
+
+**Explanation:** The sum of -1 and 0 is -1. Therefore index<sub>1</sub> = 1, index<sub>2</sub> = 2. We return [1, 2]. 
+
+**Constraints:**
+
+*   <code>2 <= numbers.length <= 3 * 10<sup>4</sup></code>
+*   `-1000 <= numbers[i] <= 1000`
+*   `numbers` is sorted in **non-decreasing order**.
+*   `-1000 <= target <= 1000`
+*   The tests are generated such that there is **exactly one solution**.

LeetCodeNet/G0101_0200/S0172_factorial_trailing_zeroes/Solution.cs

@@ -0,0 +1,17 @@
+namespace LeetCodeNet.G0101_0200.S0172_factorial_trailing_zeroes {
+
+// #Medium #Top_Interview_Questions #Math #Udemy_Integers #Top_Interview_150_Math
+// #2025_07_13_Time_0_ms_(100.00%)_Space_29.27_MB_(31.68%)
+
+public class Solution {
+    public int TrailingZeroes(int n) {
+        int baseN = 5;
+        int count = 0;
+        while (n >= baseN) {
+            count += n / baseN;
+            baseN = baseN * 5;
+        }
+        return count;
+    }
+}
+}

LeetCodeNet/G0101_0200/S0172_factorial_trailing_zeroes/readme.md

@@ -0,0 +1,35 @@
+172\. Factorial Trailing Zeroes
+
+Medium
+
+Given an integer `n`, return _the number of trailing zeroes in_ `n!`.
+
+Note that `n! = n * (n - 1) * (n - 2) * ... * 3 * 2 * 1`.
+
+**Example 1:**
+
+**Input:** n = 3
+
+**Output:** 0
+
+**Explanation:** 3! = 6, no trailing zero. 
+
+**Example 2:**
+
+**Input:** n = 5
+
+**Output:** 1
+
+**Explanation:** 5! = 120, one trailing zero. 
+
+**Example 3:**
+
+**Input:** n = 0
+
+**Output:** 0 
+
+**Constraints:**
+
+*   <code>0 <= n <= 10<sup>4</sup></code>
+
+**Follow up:** Could you write a solution that works in logarithmic time complexity?

LeetCodeNet/G0101_0200/S0173_binary_search_tree_iterator/BSTIterator.cs

@@ -0,0 +1,61 @@
+namespace LeetCodeNet.G0101_0200.S0173_binary_search_tree_iterator {
+
+// #Medium #Tree #Binary_Tree #Stack #Design #Binary_Search_Tree #Iterator
+// #Data_Structure_II_Day_17_Tree #Programming_Skills_II_Day_16 #Level_2_Day_9_Binary_Search_Tree
+// #Top_Interview_150_Binary_Tree_General #2025_07_13_Time_1_ms_(100.00%)_Space_62.77_MB_(66.48%)
+
+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 BSTIterator {
+    private TreeNode node;
+
+    public BSTIterator(TreeNode root) {
+        node = root;
+    }
+
+    public int Next() {
+        int res = -1;
+        while (node != null) {
+            if (node.left != null) {
+                TreeNode rightMost = node.left;
+                while (rightMost.right != null) {
+                    rightMost = rightMost.right;
+                }
+                rightMost.right = node;
+                TreeNode temp = node.left;
+                node.left = null;
+                node = temp;
+            } else {
+                res = node.val.Value;
+                node = node.right;
+                return res;
+            }
+        }
+        return res;
+    }
+
+    public bool HasNext() {
+        return node != null;
+    }
+}
+
+/**
+ * Your BSTIterator object will be instantiated and called as such:
+ * BSTIterator obj = new BSTIterator(root);
+ * int param_1 = obj.Next();
+ * bool param_2 = obj.HasNext();
+ */
+}