numbers[index1] and numbers[index2] where 1 <= index1 < index2 <= numbers.length.
+
+Return _the indices of the two numbers,_ index1 _and_ index2_, **added by one** as an integer array_ [index1, index2] _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, index1 = 1, index2 = 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 index1 = 1, index2 = 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 index1 = 1, index2 = 2. We return [1, 2].
+
+**Constraints:**
+
+* 2 <= numbers.length <= 3 * 104
+* `-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**.
\ No newline at end of file
diff --git a/LeetCodeNet/G0101_0200/S0172_factorial_trailing_zeroes/Solution.cs b/LeetCodeNet/G0101_0200/S0172_factorial_trailing_zeroes/Solution.cs
new file mode 100644
index 0000000..f129c2c
--- /dev/null
+++ b/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;
+ }
+}
+}
diff --git a/LeetCodeNet/G0101_0200/S0172_factorial_trailing_zeroes/readme.md b/LeetCodeNet/G0101_0200/S0172_factorial_trailing_zeroes/readme.md
new file mode 100644
index 0000000..17dc991
--- /dev/null
+++ b/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:**
+
+* 0 <= n <= 104
+
+**Follow up:** Could you write a solution that works in logarithmic time complexity?
\ No newline at end of file
diff --git a/LeetCodeNet/G0101_0200/S0173_binary_search_tree_iterator/BSTIterator.cs b/LeetCodeNet/G0101_0200/S0173_binary_search_tree_iterator/BSTIterator.cs
new file mode 100644
index 0000000..66b98ff
--- /dev/null
+++ b/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();
+ */
+}
diff --git a/LeetCodeNet/G0101_0200/S0173_binary_search_tree_iterator/readme.md b/LeetCodeNet/G0101_0200/S0173_binary_search_tree_iterator/readme.md
new file mode 100644
index 0000000..458a015
--- /dev/null
+++ b/LeetCodeNet/G0101_0200/S0173_binary_search_tree_iterator/readme.md
@@ -0,0 +1,44 @@
+173\. Binary Search Tree Iterator
+
+Medium
+
+Implement the `BSTIterator` class that represents an iterator over the **[in-order traversal](https://en.wikipedia.org/wiki/Tree_traversal#In-order_(LNR))** of a binary search tree (BST):
+
+* `BSTIterator(TreeNode root)` Initializes an object of the `BSTIterator` class. The `root` of the BST is given as part of the constructor. The pointer should be initialized to a non-existent number smaller than any element in the BST.
+* `boolean hasNext()` Returns `true` if there exists a number in the traversal to the right of the pointer, otherwise returns `false`.
+* `int next()` Moves the pointer to the right, then returns the number at the pointer.
+
+Notice that by initializing the pointer to a non-existent smallest number, the first call to `next()` will return the smallest element in the BST.
+
+You may assume that `next()` calls will always be valid. That is, there will be at least a next number in the in-order traversal when `next()` is called.
+
+**Example 1:**
+
+
+
+**Input** ["BSTIterator", "next", "next", "hasNext", "next", "hasNext", "next", "hasNext", "next", "hasNext"] [[[7, 3, 15, null, null, 9, 20]], [], [], [], [], [], [], [], [], []]
+
+**Output:** [null, 3, 7, true, 9, true, 15, true, 20, false]
+
+**Explanation:**
+
+ BSTIterator bSTIterator = new BSTIterator([7, 3, 15, null, null, 9, 20]);
+ bSTIterator.next(); // return 3
+ bSTIterator.next(); // return 7
+ bSTIterator.hasNext(); // return True
+ bSTIterator.next(); // return 9
+ bSTIterator.hasNext(); // return True
+ bSTIterator.next(); // return 15
+ bSTIterator.hasNext(); // return True
+ bSTIterator.next(); // return 20
+ bSTIterator.hasNext(); // return False
+
+**Constraints:**
+
+* The number of nodes in the tree is in the range [1, 105].
+* 0 <= Node.val <= 106
+* At most 105 calls will be made to `hasNext`, and `next`.
+
+**Follow up:**
+
+* Could you implement `next()` and `hasNext()` to run in average `O(1)` time and use `O(h)` memory, where `h` is the height of the tree?
\ No newline at end of file
diff --git a/LeetCodeNet/G0101_0200/S0188_best_time_to_buy_and_sell_stock_iv/Solution.cs b/LeetCodeNet/G0101_0200/S0188_best_time_to_buy_and_sell_stock_iv/Solution.cs
new file mode 100644
index 0000000..31328b0
--- /dev/null
+++ b/LeetCodeNet/G0101_0200/S0188_best_time_to_buy_and_sell_stock_iv/Solution.cs
@@ -0,0 +1,24 @@
+namespace LeetCodeNet.G0101_0200.S0188_best_time_to_buy_and_sell_stock_iv {
+
+// #Hard #Array #Dynamic_Programming #Top_Interview_150_Multidimensional_DP
+// #2025_07_13_Time_1_ms_(100.00%)_Space_42.53_MB_(87.70%)
+
+public class Solution {
+ public int MaxProfit(int k, int[] prices) {
+ int n = prices.Length;
+ int[] dp = new int[k + 1];
+ int[] maxdp = new int[k + 1];
+ for (int i = 0; i <= k; i++) {
+ maxdp[i] = int.MinValue;
+ }
+ for (int i = 1; i <= n; i++) {
+ maxdp[0] = System.Math.Max(maxdp[0], dp[0] - prices[i - 1]);
+ for (int j = k; j >= 1; j--) {
+ maxdp[j] = System.Math.Max(maxdp[j], dp[j] - prices[i - 1]);
+ dp[j] = System.Math.Max(maxdp[j - 1] + prices[i - 1], dp[j]);
+ }
+ }
+ return dp[k];
+ }
+}
+}
diff --git a/LeetCodeNet/G0101_0200/S0188_best_time_to_buy_and_sell_stock_iv/readme.md b/LeetCodeNet/G0101_0200/S0188_best_time_to_buy_and_sell_stock_iv/readme.md
new file mode 100644
index 0000000..db592c5
--- /dev/null
+++ b/LeetCodeNet/G0101_0200/S0188_best_time_to_buy_and_sell_stock_iv/readme.md
@@ -0,0 +1,31 @@
+188\. Best Time to Buy and Sell Stock IV
+
+Hard
+
+You are given an integer array `prices` where `prices[i]` is the price of a given stock on the ith day, and an integer `k`.
+
+Find the maximum profit you can achieve. You may complete at most `k` transactions.
+
+**Note:** You may not engage in multiple transactions simultaneously (i.e., you must sell the stock before you buy again).
+
+**Example 1:**
+
+**Input:** k = 2, prices = [2,4,1]
+
+**Output:** 2
+
+**Explanation:** Buy on day 1 (price = 2) and sell on day 2 (price = 4), profit = 4-2 = 2.
+
+**Example 2:**
+
+**Input:** k = 2, prices = [3,2,6,5,0,3]
+
+**Output:** 7
+
+**Explanation:** Buy on day 2 (price = 2) and sell on day 3 (price = 6), profit = 6-2 = 4. Then buy on day 5 (price = 0) and sell on day 6 (price = 3), profit = 3-0 = 3.
+
+**Constraints:**
+
+* `0 <= k <= 100`
+* `0 <= prices.length <= 1000`
+* `0 <= prices[i] <= 1000`
\ No newline at end of file
diff --git a/LeetCodeNet/G0101_0200/S0190_reverse_bits/Solution.cs b/LeetCodeNet/G0101_0200/S0190_reverse_bits/Solution.cs
new file mode 100644
index 0000000..809f9e4
--- /dev/null
+++ b/LeetCodeNet/G0101_0200/S0190_reverse_bits/Solution.cs
@@ -0,0 +1,23 @@
+namespace LeetCodeNet.G0101_0200.S0190_reverse_bits {
+
+// #Easy #Top_Interview_Questions #Bit_Manipulation #Divide_and_Conquer
+// #Algorithm_I_Day_14_Bit_Manipulation #Udemy_Bit_Manipulation #Top_Interview_150_Bit_Manipulation
+// #2025_07_13_Time_18_ms_(93.43%)_Space_29.36_MB_(37.09%)
+
+public class Solution {
+ // you need treat n as an unsigned value
+ public uint reverseBits(uint n) {
+ uint ret = 0;
+ // because there are 32 bits in total
+ for (int i = 0; i < 32; i++) {
+ ret = ret << 1;
+ // If the bit is 1 we OR it with 1, ie add 1
+ if ((n & 1) > 0) {
+ ret = ret | 1;
+ }
+ n = n >> 1;
+ }
+ return ret;
+ }
+}
+}
diff --git a/LeetCodeNet/G0101_0200/S0190_reverse_bits/readme.md b/LeetCodeNet/G0101_0200/S0190_reverse_bits/readme.md
new file mode 100644
index 0000000..cd57e65
--- /dev/null
+++ b/LeetCodeNet/G0101_0200/S0190_reverse_bits/readme.md
@@ -0,0 +1,32 @@
+190\. Reverse Bits
+
+Easy
+
+Reverse bits of a given 32 bits unsigned integer.
+
+**Note:**
+
+* Note that in some languages, such as Java, there is no unsigned integer type. In this case, both input and output will be given as a signed integer type. They should not affect your implementation, as the integer's internal binary representation is the same, whether it is signed or unsigned.
+* In Java, the compiler represents the signed integers using [2's complement notation](https://en.wikipedia.org/wiki/Two%27s_complement). Therefore, in **Example 2** above, the input represents the signed integer `-3` and the output represents the signed integer `-1073741825`.
+
+**Example 1:**
+
+**Input:** n = 00000010100101000001111010011100
+
+**Output:** 964176192 (00111001011110000010100101000000)
+
+**Explanation:** The input binary string **00000010100101000001111010011100** represents the unsigned integer 43261596, so return 964176192 which its binary representation is **00111001011110000010100101000000**.
+
+**Example 2:**
+
+**Input:** n = 11111111111111111111111111111101
+
+**Output:** 3221225471 (10111111111111111111111111111111)
+
+**Explanation:** The input binary string **11111111111111111111111111111101** represents the unsigned integer 4294967293, so return 3221225471 which its binary representation is **10111111111111111111111111111111**.
+
+**Constraints:**
+
+* The input must be a **binary string** of length `32`
+
+**Follow up:** If this function is called many times, how would you optimize it?
\ No newline at end of file
Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.
Alternative Proxies: