Added tasks 167-190

Author: javadev

LeetCodeNet/G0101_0200/S0167_two_sum_ii_input_array_is_sorted/readme.md

@@ -0,0 +1,69 @@
+[![](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)
+
+## 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**.
+
+## Solution
+
+```csharp
+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/S0172_factorial_trailing_zeroes/readme.md

@@ -0,0 +1,54 @@
+[![](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)
+
+## 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?
+
+## Solution
+
+```csharp
+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/S0173_binary_search_tree_iterator/readme.md

@@ -0,0 +1,106 @@
+[![](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)
+
+## 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:**
+
+![](https://assets.leetcode.com/uploads/2018/12/25/bst-tree.png)
+
+**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 <code>[1, 10<sup>5</sup>]</code>.
+*   <code>0 <= Node.val <= 10<sup>6</sup></code>
+*   At most <code>10<sup>5</sup></code> 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?
+
+## 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 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();
+}
+```

LeetCodeNet/G0101_0200/S0188_best_time_to_buy_and_sell_stock_iv/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)
+
+## 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 <code>i<sup>th</sup></code> 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`
+
+## Solution
+
+```csharp
+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];
+    }
+}
+```

LeetCodeNet/G0101_0200/S0190_reverse_bits/readme.md

@@ -0,0 +1,56 @@
+[![](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)
+
+## 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?
+
+## Solution
+
+```csharp
+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;
+    }
+}
+```