Added tasks 41-148

Author: javadev

README.md

@@ -53,7 +53,7 @@ To solve the Add Two Numbers problem in Swift using a `Solution` class, we'll fo
 Here's the implementation:
 
 ```swift
-/*
+/**
  * Definition for singly-linked list.
  * public class ListNode {
  *     public var val: Int

src/main/swift/g0001_0100/s0002_add_two_numbers/readme.md

@@ -50,7 +50,7 @@ To solve the "Swap Nodes in Pairs" problem in Swift with a `Solution` class, we
 Here's the implementation:
 
 ```swift
-/*
+/**
  * Definition for singly-linked list.
  * public class ListNode {
  *     public var val: Int

src/main/swift/g0001_0100/s0024_swap_nodes_in_pairs/readme.md

@@ -66,7 +66,7 @@ To solve the "Reverse Nodes in k-Group" problem in Swift with a `Solution` class
 Here's the implementation:
 
 ```swift
-/*
+/**
  * Definition for singly-linked list.
  * public class ListNode {
  *     public var val: Int

src/main/swift/g0001_0100/s0025_reverse_nodes_in_k_group/readme.md

@@ -0,0 +1,68 @@
+[![](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)
+
+## 41\. First Missing Positive
+
+Hard
+
+Given an unsorted integer array `nums`, return the smallest missing positive integer.
+
+You must implement an algorithm that runs in `O(n)` time and uses constant extra space.
+
+**Example 1:**
+
+**Input:** nums = [1,2,0]
+
+**Output:** 3 
+
+**Example 2:**
+
+**Input:** nums = [3,4,-1,1]
+
+**Output:** 2 
+
+**Example 3:**
+
+**Input:** nums = [7,8,9,11,12]
+
+**Output:** 1 
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 5 * 10<sup>5</sup></code>
+*   <code>-2<sup>31</sup> <= nums[i] <= 2<sup>31</sup> - 1</code>
+
+To solve the "First Missing Positive" problem in Swift with a `Solution` class, we can follow these steps:
+
+1. Define a `Solution` class.
+2. Define a method named `firstMissingPositive` that takes an array of integers `nums` as input and returns the smallest missing positive integer.
+3. Iterate through the array and mark the positive integers found by negating the value at the corresponding index.
+4. Iterate through the modified array again and return the index of the first positive number (which is the smallest missing positive integer).
+5. If no positive number is found, return `nums.length + 1`.
+
+Here's the implementation:
+
+```swift
+public class Solution {
+    public func firstMissingPositive(_ nums: [Int]) -> Int {
+        var nums = nums
+        for i in 0..<nums.count {
+            while nums[i] > 0 && nums[i] <= nums.count && nums[i] != i + 1 {
+                let val = nums[i]
+                if nums[val - 1] == val {
+                    break
+                }
+                nums.swapAt(i, val - 1)
+            }
+        }
+        for i in 0..<nums.count {
+            if nums[i] != i + 1 {
+                return i + 1
+            }
+        }
+        return nums.count + 1
+    }
+}
+```
+
+This implementation provides a solution to the "First Missing Positive" problem in Swift. It marks positive integers found by negating the value at the corresponding index and then iterates through the modified array to find the smallest missing positive integer. If no positive number is found, it returns `nums.length + 1`.

src/main/swift/g0001_0100/s0041_first_missing_positive/readme.md

@@ -0,0 +1,77 @@
+[![](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)
+
+## 42\. Trapping Rain Water
+
+Hard
+
+Given `n` non-negative integers representing an elevation map where the width of each bar is `1`, compute how much water it can trap after raining.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2018/10/22/rainwatertrap.png)
+
+**Input:** height = [0,1,0,2,1,0,1,3,2,1,2,1]
+
+**Output:** 6
+
+**Explanation:** The above elevation map (black section) is represented by array [0,1,0,2,1,0,1,3,2,1,2,1]. In this case, 6 units of rain water (blue section) are being trapped. 
+
+**Example 2:**
+
+**Input:** height = [4,2,0,3,2,5]
+
+**Output:** 9 
+
+**Constraints:**
+
+*   `n == height.length`
+*   <code>1 <= n <= 2 * 10<sup>4</sup></code>
+*   <code>0 <= height[i] <= 10<sup>5</sup></code>
+
+To solve the "Trapping Rain Water" problem in Swift with a `Solution` class, we can follow these steps:
+
+1. Define a `Solution` class.
+2. Define a method named `trap` that takes an array of integers `height` as input and returns the amount of water it can trap after raining.
+3. Initialize two pointers `left` and `right` at the beginning and end of the array respectively.
+4. Initialize two variables `leftMax` and `rightMax` to keep track of the maximum height of bars encountered from the left and right directions respectively.
+5. Iterate through the array using the two pointers:
+   - Update `leftMax` as the maximum of `leftMax` and `height[left]`.
+   - Update `rightMax` as the maximum of `rightMax` and `height[right]`.
+   - If `height[left] < height[right]`, calculate the water trapped at the current position using `leftMax` and subtract the height of the current bar. Move `left` pointer to the right.
+   - Otherwise, calculate the water trapped at the current position using `rightMax` and subtract the height of the current bar. Move `right` pointer to the left.
+6. Continue this process until the two pointers meet.
+7. Return the total amount of water trapped.
+
+Here's the implementation:
+
+```swift
+class Solution {
+    func trap(_ height: [Int]) -> Int {
+        var ans = 0
+        var left = 0, right = height.count - 1
+        var leftMax = 0, rightMax = 0
+        while left < right {
+            let leftHeight = height[left], rightHeight = height[right]
+            if leftHeight < rightHeight {
+                if leftHeight >= leftMax {
+                    leftMax = leftHeight
+                } else {
+                    ans += leftMax - leftHeight
+                }
+                left += 1
+            } else {
+                if rightHeight >= rightMax {
+                    rightMax = rightHeight
+                } else {
+                    ans += rightMax - rightHeight
+                }
+                right -= 1
+            }
+        }
+        return ans
+    }
+}
+```
+
+This implementation provides a solution to the "Trapping Rain Water" problem in Swift. It calculates the amount of water that can be trapped between bars by using two pointers to track the left and right boundaries and two variables to track the maximum heights of bars encountered from the left and right directions.

src/main/swift/g0001_0100/s0042_trapping_rain_water/readme.md

@@ -0,0 +1,71 @@
+[![](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)
+
+## 45\. Jump Game II
+
+Medium
+
+Given an array of non-negative integers `nums`, you are initially positioned at the first index of the array.
+
+Each element in the array represents your maximum jump length at that position.
+
+Your goal is to reach the last index in the minimum number of jumps.
+
+You can assume that you can always reach the last index.
+
+**Example 1:**
+
+**Input:** nums = [2,3,1,1,4]
+
+**Output:** 2
+
+**Explanation:** The minimum number of jumps to reach the last index is 2. Jump 1 step from index 0 to 1, then 3 steps to the last index. 
+
+**Example 2:**
+
+**Input:** nums = [2,3,0,1,4]
+
+**Output:** 2 
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>4</sup></code>
+*   `0 <= nums[i] <= 1000`
+
+To solve the "Jump Game II" problem in Swift with a `Solution` class, we can follow these steps:
+
+1. Define a `Solution` class.
+2. Define a method named `jump` that takes an array of non-negative integers `nums` as input and returns the minimum number of jumps required to reach the last index.
+3. Initialize variables `maxReach`, `steps`, and `end` to keep track of the maximum reachable position, the number of steps taken, and the end position respectively. Initialize `maxReach` to 0 and `end` to 0.
+4. Iterate through the array from index 0 to `nums.length - 2`:
+   - Update `maxReach` as the maximum of `maxReach` and `i + nums[i]`.
+   - If the current index `i` equals `end`, update `end` to `maxReach` and increment `steps`.
+5. Return `steps`.
+
+Here's the implementation:
+
+```swift
+public class Solution {
+    public func jump(_ nums: [Int]) -> Int {
+        var length = 0
+        var maxLength = 0
+        var minJump = 0
+
+        for i in 0..<nums.count - 1 {
+            length -= 1
+            maxLength -= 1
+            maxLength = max(maxLength, nums[i])
+            if length <= 0 {
+                length = maxLength
+                minJump += 1
+            }
+            if length >= nums.count - i - 1 {
+                return minJump
+            }
+        }
+        return minJump
+    }
+}
+```
+
+This implementation provides a solution to the "Jump Game II" problem in Swift. It calculates the minimum number of jumps required to reach the last index by iterating through the array and updating the maximum reachable position and the end position accordingly.

src/main/swift/g0001_0100/s0045_jump_game_ii/readme.md

@@ -0,0 +1,81 @@
+[![](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)
+
+## 46\. Permutations
+
+Medium
+
+Given an array `nums` of distinct integers, return _all the possible permutations_. You can return the answer in **any order**.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3]
+
+**Output:** [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]] 
+
+**Example 2:**
+
+**Input:** nums = [0,1]
+
+**Output:** [[0,1],[1,0]] 
+
+**Example 3:**
+
+**Input:** nums = [1]
+
+**Output:** [[1]] 
+
+**Constraints:**
+
+*   `1 <= nums.length <= 6`
+*   `-10 <= nums[i] <= 10`
+*   All the integers of `nums` are **unique**.
+
+To solve the "Permutations" problem in Swift with a `Solution` class, we can follow these steps:
+
+1. Define a `Solution` class.
+2. Define a method named `permute` that takes an array of distinct integers `nums` as input and returns a list of all possible permutations.
+3. Create an empty list to store the result permutations.
+4. Call a recursive helper function named `permuteHelper` to generate permutations.
+5. Inside the `permuteHelper` function:
+   - If the current permutation size equals the length of the input array `nums`, add a copy of the current permutation to the result list.
+   - Otherwise, iterate through each element of `nums`:
+     - If the current element is not already in the permutation, add it to the current permutation, and recursively call `permuteHelper` with the updated permutation and the remaining elements of `nums`.
+     - After the recursive call, remove the last element from the permutation to backtrack.
+6. Return the result list.
+
+Here's the implementation:
+
+```swift
+public class Solution {
+    public func permute(_ nums: [Int]) -> [[Int]] {
+        if nums.isEmpty {
+            return []
+        }
+        var finalResult = \[\[Int]]()
+        var currResult = [Int]()
+        var used = [Bool](repeating: false, count: nums.count)
+        permuteRecur(nums, &finalResult, &currResult, &used)
+        return finalResult
+    }
+
+    private func permuteRecur(_ nums: [Int], _ finalResult: inout [[Int]], _ currResult: inout [Int], _ used: inout [Bool]) {
+        if currResult.count == nums.count {
+            finalResult.append(currResult)
+            return
+        }
+        for i in 0..<nums.count {
+            if used[i] {
+                continue
+            }
+            currResult.append(nums[i])
+            used[i] = true
+            permuteRecur(nums, &finalResult, &currResult, &used)
+            used[i] = false
+            currResult.removeLast()
+        }
+    }
+}
+```
+
+This implementation provides a solution to the "Permutations" problem in Swift. It generates all possible permutations of the given array of distinct integers using backtracking.