Added tasks 215-1143

Author: javadev

README.md

@@ -0,0 +1,108 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Swift/LeetCode-in-Swift?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Swift/LeetCode-in-Swift)
+[![](https://img.shields.io/github/forks/LeetCode-in-Swift/LeetCode-in-Swift?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Swift/LeetCode-in-Swift/fork)
+
+## 152\. Maximum Product Subarray
+
+Medium
+
+Given an integer array `nums`, find a contiguous non-empty subarray within the array that has the largest product, and return _the product_.
+
+It is **guaranteed** that the answer will fit in a **32-bit** integer.
+
+A **subarray** is a contiguous subsequence of the array.
+
+**Example 1:**
+
+**Input:** nums = [2,3,-2,4]
+
+**Output:** 6
+
+**Explanation:** [2,3] has the largest product 6. 
+
+**Example 2:**
+
+**Input:** nums = [-2,0,-1]
+
+**Output:** 0
+
+**Explanation:** The result cannot be 2, because [-2,-1] is not a subarray. 
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 2 * 10<sup>4</sup></code>
+*   `-10 <= nums[i] <= 10`
+*   The product of any prefix or suffix of `nums` is **guaranteed** to fit in a **32-bit** integer.
+
+To solve the "152. Maximum Product Subarray" problem in Swift using the provided `Solution` class:
+
+### Steps to Solve the Problem
+
+1. **Initialize Variables**:
+   - Create a variable `left` to keep track of the product of elements from the left.
+   - Create a variable `right` to keep track of the product of elements from the right.
+   - Initialize a variable `res` to store the maximum product found so far.
+
+2. **Iterate Through the Array**:
+   - Use a loop to iterate through the array from the start to the end.
+   - Simultaneously iterate through the array from the end to the start.
+
+3. **Update Products**:
+   - For each iteration, update the `left` product by multiplying it with the current element from the left side.
+   - Update the `right` product by multiplying it with the current element from the right side.
+
+4. **Handle Zeros**:
+   - If the `left` product is zero, reset it to one to start a new subarray.
+   - Similarly, if the `right` product is zero, reset it to one to start a new subarray.
+
+5. **Update Maximum Product**:
+   - Update the `res` with the maximum value between `res`, `left`, and `right`.
+
+6. **Return Result**:
+   - After completing the loop, return the maximum product found, converted to an integer.
+
+### Swift Solution
+
+```swift
+class Solution {
+    func maxProduct(_ nums: [Int]) -> Int {
+        var left: Double = 1
+        var right: Double = 1
+        var j = nums.count - 1
+        var res: Double = Double(Int.min)
+        
+        for i in 0..<nums.count {
+            if left == 0 { left = 1 }
+            if right == 0 { right = 1 }
+            
+            left *= Double(nums[i])
+            right *= Double(nums[j])
+            
+            j -= 1
+            
+            res = max(res, max(left, right))
+        }
+        
+        return Int(res)
+    }
+}
+```
+
+### Explanation of the Example Cases
+
+- **Example 1**:
+  - **Input**: `nums = [2,3,-2,4]`
+  - The contiguous subarray `[2,3]` has the largest product `6`.
+  - **Output**: `6`
+
+- **Example 2**:
+  - **Input**: `nums = [-2,0,-1]`
+  - The maximum product subarray is `[0]` which has a product of `0`.
+  - **Output**: `0`
+
+### Constraints
+
+- `1 <= nums.length <= 2 * 10^4`
+- `-10 <= nums[i] <= 10`
+- The product of any prefix or suffix of `nums` is guaranteed to fit in a 32-bit integer.
+
+By following these steps and using the provided solution, you can solve the "152. Maximum Product Subarray" problem in Swift efficiently.

src/main/swift/g0101_0200/s0152_maximum_product_subarray/readme.md

@@ -0,0 +1,38 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Swift/LeetCode-in-Swift?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Swift/LeetCode-in-Swift)
+[![](https://img.shields.io/github/forks/LeetCode-in-Swift/LeetCode-in-Swift?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Swift/LeetCode-in-Swift/fork)
+
+## 215\. Kth Largest Element in an Array
+
+Medium
+
+Given an integer array `nums` and an integer `k`, return _the_ <code>k<sup>th</sup></code> _largest element in the array_.
+
+Note that it is the <code>k<sup>th</sup></code> largest element in the sorted order, not the <code>k<sup>th</sup></code> distinct element.
+
+**Example 1:**
+
+**Input:** nums = [3,2,1,5,6,4], k = 2
+
+**Output:** 5 
+
+**Example 2:**
+
+**Input:** nums = [3,2,3,1,2,4,5,5,6], k = 4
+
+**Output:** 4 
+
+**Constraints:**
+
+*   <code>1 <= k <= nums.length <= 10<sup>4</sup></code>
+*   <code>-10<sup>4</sup> <= nums[i] <= 10<sup>4</sup></code>
+
+## Solution
+
+```swift
+class Solution {
+    func findKthLargest(_ nums: [Int], _ k: Int) -> Int {
+        let sortedNums = nums.sorted()
+        return sortedNums[sortedNums.count - k]
+    }
+}
+```

src/main/swift/g0201_0300/s0215_kth_largest_element_in_an_array/readme.md

@@ -0,0 +1,63 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Swift/LeetCode-in-Swift?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Swift/LeetCode-in-Swift)
+[![](https://img.shields.io/github/forks/LeetCode-in-Swift/LeetCode-in-Swift?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Swift/LeetCode-in-Swift/fork)
+
+## 221\. Maximal Square
+
+Medium
+
+Given an `m x n` binary `matrix` filled with `0`'s and `1`'s, _find the largest square containing only_ `1`'s _and return its area_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/11/26/max1grid.jpg)
+
+**Input:** matrix = \[\["1","0","1","0","0"],["1","0","1","1","1"],["1","1","1","1","1"],["1","0","0","1","0"]]
+
+**Output:** 4 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/11/26/max2grid.jpg)
+
+**Input:** matrix = \[\["0","1"],["1","0"]]
+
+**Output:** 1 
+
+**Example 3:**
+
+**Input:** matrix = \[\["0"]]
+
+**Output:** 0 
+
+**Constraints:**
+
+*   `m == matrix.length`
+*   `n == matrix[i].length`
+*   `1 <= m, n <= 300`
+*   `matrix[i][j]` is `'0'` or `'1'`.
+
+## Solution
+
+```swift
+class Solution {
+    func maximalSquare(_ matrix: [[Character]]) -> Int {
+        guard matrix.count > 0 && matrix[0].count > 0 else { return 0 }
+        var square = Array(repeating: Array(repeating: 0, count: matrix[0].count), count: matrix.count)
+        var curMaxLen = 0
+        
+        for i in 0..<matrix.count {
+            for j in 0..<matrix[0].count {
+                // when first col or row, set value manually, avoid "-1" index as well
+                if i == 0 || j == 0 {
+                    square[i][j] = Int(String(matrix[i][j]))!
+                }
+                else if matrix[i][j] == "1" {
+                    square[i][j] = min(min(square[i-1][j], square[i][j-1]), square[i-1][j-1]) + 1
+                }
+                curMaxLen = max(curMaxLen, square[i][j])
+            }
+        }
+        return curMaxLen*curMaxLen
+    }
+}
+```

src/main/swift/g0201_0300/s0221_maximal_square/readme.md

@@ -0,0 +1,70 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Swift/LeetCode-in-Swift?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Swift/LeetCode-in-Swift)
+[![](https://img.shields.io/github/forks/LeetCode-in-Swift/LeetCode-in-Swift?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Swift/LeetCode-in-Swift/fork)
+
+## 226\. Invert Binary Tree
+
+Easy
+
+Given the `root` of a binary tree, invert the tree, and return _its root_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/03/14/invert1-tree.jpg)
+
+**Input:** root = [4,2,7,1,3,6,9]
+
+**Output:** [4,7,2,9,6,3,1] 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/03/14/invert2-tree.jpg)
+
+**Input:** root = [2,1,3]
+
+**Output:** [2,3,1] 
+
+**Example 3:**
+
+**Input:** root = []
+
+**Output:** [] 
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range `[0, 100]`.
+*   `-100 <= Node.val <= 100`
+
+## Solution
+
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init() { self.val = 0; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+ *         self.val = val
+ *         self.left = left
+ *         self.right = right
+ *     }
+ * }
+ */
+class Solution {
+    func invertTree(_ root: TreeNode?) -> TreeNode? {
+            if root?.left != nil || root?.right != nil {
+        let leftTree = root?.left
+        let rightTree = root?.right
+        
+        root?.left = rightTree
+        root?.right = leftTree
+        
+        invertTree(root?.left)
+        invertTree(root?.right)
+    }
+    return root
+    }
+}
+```

src/main/swift/g0201_0300/s0226_invert_binary_tree/readme.md

@@ -0,0 +1,83 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Swift/LeetCode-in-Swift?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Swift/LeetCode-in-Swift)
+[![](https://img.shields.io/github/forks/LeetCode-in-Swift/LeetCode-in-Swift?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Swift/LeetCode-in-Swift/fork)
+
+## 230\. Kth Smallest Element in a BST
+
+Medium
+
+Given the `root` of a binary search tree, and an integer `k`, return _the_ <code>k<sup>th</sup></code> _smallest value (**1-indexed**) of all the values of the nodes in the tree_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/01/28/kthtree1.jpg)
+
+**Input:** root = [3,1,4,null,2], k = 1
+
+**Output:** 1 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/01/28/kthtree2.jpg)
+
+**Input:** root = [5,3,6,2,4,null,null,1], k = 3
+
+**Output:** 3 
+
+**Constraints:**
+
+*   The number of nodes in the tree is `n`.
+*   <code>1 <= k <= n <= 10<sup>4</sup></code>
+*   <code>0 <= Node.val <= 10<sup>4</sup></code>
+
+**Follow up:** If the BST is modified often (i.e., we can do insert and delete operations) and you need to find the kth smallest frequently, how would you optimize?
+
+## Solution
+
+```swift
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public var val: Int
+ *     public var left: TreeNode?
+ *     public var right: TreeNode?
+ *     public init() { self.val = 0; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+ *     public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+ *         self.val = val
+ *         self.left = left
+ *         self.right = right
+ *     }
+ * }
+ */
+class Solution {
+    func kthSmallest(_ root: TreeNode?, _ k: Int) -> Int {
+        var vals = [Int]()
+        var minVal = Int.max
+        var maxVal = Int.min
+        traverse(root, &vals, &minVal, &maxVal)
+        var countingArray = Array(repeating: -1, count: maxVal - minVal + 1)
+        for val in vals { countingArray[val - minVal] = val }
+        var i = 0
+        for val in countingArray {
+            guard val != -1 else { continue }
+            i += 1
+            if i == k { return val }
+        }
+        return -1
+    }
+
+    private func traverse(
+        _ node: TreeNode?, 
+        _ arr: inout [Int], 
+        _ minVal: inout Int, 
+        _ maxVal: inout Int
+    ) {
+        guard let node else { return }
+        minVal = min(minVal, node.val)
+        maxVal = max(maxVal, node.val)
+        arr.append(node.val)
+        traverse(node.left, &arr, &minVal, &maxVal)
+        traverse(node.right, &arr, &minVal, &maxVal)
+    }
+}
+```