Added swift solutions

Author: javadev

README.md

@@ -2,7 +2,6 @@
 [![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
 > ["For coding interview preparation, LeetCode is one of the best online resource providing a rich library of more than 300 real coding interview questions for you to practice from using one of the 7 supported languages - C, C++, Java, Python, C#, JavaScript, Ruby."](https://www.quora.com/How-effective-is-Leetcode-for-preparing-for-technical-interviews)
 
-* [SQL I](#sql-i)
 * [Level 1](#level-1)
 * [Level 2](#level-2)
 * [Udemy](#udemy)
@@ -16,58 +15,7 @@
 * [Programming Skills I](#programming-skills-i)
 * [Programming Skills II](#programming-skills-ii)
 * [Graph Theory I](#graph-theory-i)
-
-### SQL I
-
-#### Day 1 Select
-
-| <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
-|-|-|-|-|-|-|-
-
-#### Day 2 Select and Order
-
-| <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
-|-|-|-|-|-|-|-
-
-#### Day 3 String Processing Functions
-
-| <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
-|-|-|-|-|-|-|-
-
-#### Day 4 Union and Select
-
-| <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
-|-|-|-|-|-|-|-
-
-#### Day 5 Union
-
-| <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
-|-|-|-|-|-|-|-
-
-#### Day 6 Union
-
-| <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
-|-|-|-|-|-|-|-
-
-#### Day 7 Function
-
-| <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
-|-|-|-|-|-|-|-
-
-#### Day 8 Function
-
-| <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
-|-|-|-|-|-|-|-
-
-#### Day 9 Control of Flow
-
-| <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
-|-|-|-|-|-|-|-
-
-#### Day 10 Where
-
-| <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
-|-|-|-|-|-|-|-
+* [SQL I](#sql-i)
 
 ### Level 1
 
@@ -1398,6 +1346,58 @@
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-|-
 
+### SQL I
+
+#### Day 1 Select
+
+| <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
+|-|-|-|-|-|-|-
+
+#### Day 2 Select and Order
+
+| <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
+|-|-|-|-|-|-|-
+
+#### Day 3 String Processing Functions
+
+| <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
+|-|-|-|-|-|-|-
+
+#### Day 4 Union and Select
+
+| <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
+|-|-|-|-|-|-|-
+
+#### Day 5 Union
+
+| <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
+|-|-|-|-|-|-|-
+
+#### Day 6 Union
+
+| <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
+|-|-|-|-|-|-|-
+
+#### Day 7 Function
+
+| <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
+|-|-|-|-|-|-|-
+
+#### Day 8 Function
+
+| <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
+|-|-|-|-|-|-|-
+
+#### Day 9 Control of Flow
+
+| <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
+|-|-|-|-|-|-|-
+
+#### Day 10 Where
+
+| <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
+|-|-|-|-|-|-|-
+
 ## Algorithms
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %

src/main/swift/g0001_0100/s0002_add_two_numbers/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/s0024_swap_nodes_in_pairs/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/s0025_reverse_nodes_in_k_group/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/s0062_unique_paths/readme.md

@@ -0,0 +1,87 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 62\. Unique Paths
+
+Medium
+
+A robot is located at the top-left corner of a `m x n` grid (marked 'Start' in the diagram below).
+
+The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked 'Finish' in the diagram below).
+
+How many possible unique paths are there?
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2018/10/22/robot_maze.png)
+
+**Input:** m = 3, n = 7
+
+**Output:** 28 
+
+**Example 2:**
+
+**Input:** m = 3, n = 2
+
+**Output:** 3
+
+**Explanation:**
+
+    From the top-left corner, there are a total of 3 ways to reach the bottom-right corner:
+    1. Right -> Down -> Down
+    2. Down -> Down -> Right
+    3. Down -> Right -> Down 
+
+**Example 3:**
+
+**Input:** m = 7, n = 3
+
+**Output:** 28 
+
+**Example 4:**
+
+**Input:** m = 3, n = 3
+
+**Output:** 6 
+
+**Constraints:**
+
+*   `1 <= m, n <= 100`
+*   It's guaranteed that the answer will be less than or equal to <code>2 * 10<sup>9</sup></code>.
+
+To solve the "Unique Paths" problem in Swift with the Solution class, follow these steps:
+
+1. Define a method `uniquePaths` in the `Solution` class that takes two integers `m` and `n` as input and returns the number of unique paths from the top-left corner to the bottom-right corner of an `m x n` grid.
+2. Initialize a 2D array `dp` of size `m x n` to store the number of unique paths for each position in the grid.
+3. Initialize the first row and first column of `dp` to 1 since there is only one way to reach any position in the first row or column (by moving only right or down).
+4. Iterate over each position `(i, j)` in the grid, starting from the second row and second column:
+   - Update `dp[i][j]` by adding the number of unique paths from the cell above `(i-1, j)` and the cell to the left `(i, j-1)`.
+5. Return the value of `dp[m-1][n-1]`, which represents the number of unique paths to reach the bottom-right corner of the grid.
+
+Here's the implementation of the `uniquePaths` method in Swift:
+
+```swift
+public class Solution {
+    public func uniquePaths(_ m: Int, _ n: Int) -> Int {
+        var dp = Array(repeating: Array(repeating: 0, count: n), count: m)
+        
+        for i in 0..<m {
+            dp[i][0] = 1
+        }
+        
+        for j in 0..<n {
+            dp[0][j] = 1
+        }
+        
+        for i in 1..<m {
+            for j in 1..<n {
+                dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
+            }
+        }
+        
+        return dp[m - 1][n - 1]
+    }
+}
+```
+
+This implementation efficiently calculates the number of unique paths using dynamic programming, with a time complexity of O(m * n) and a space complexity of O(m * n).

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

@@ -0,0 +1,75 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 64\. Minimum Path Sum
+
+Medium
+
+Given a `m x n` `grid` filled with non-negative numbers, find a path from top left to bottom right, which minimizes the sum of all numbers along its path.
+
+**Note:** You can only move either down or right at any point in time.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/11/05/minpath.jpg)
+
+**Input:** grid = \[\[1,3,1],[1,5,1],[4,2,1]]
+
+**Output:** 7
+
+**Explanation:** Because the path 1 → 3 → 1 → 1 → 1 minimizes the sum. 
+
+**Example 2:**
+
+**Input:** grid = \[\[1,2,3],[4,5,6]]
+
+**Output:** 12 
+
+**Constraints:**
+
+*   `m == grid.length`
+*   `n == grid[i].length`
+*   `1 <= m, n <= 200`
+*   `0 <= grid[i][j] <= 100`
+
+To solve the "Minimum Path Sum" problem in Swift with the Solution class, follow these steps:
+
+1. Define a method `minPathSum` in the `Solution` class that takes a 2D grid of non-negative numbers as input and returns the minimum sum of all numbers along the path from the top-left corner to the bottom-right corner of the grid.
+2. Initialize a 2D array `dp` of size `m x n`, where `dp[i][j]` represents the minimum sum of the path from the top-left corner to position `(i, j)` in the grid.
+3. Initialize `dp[0][0]` to the value of the top-left cell in the grid.
+4. Initialize the first row and first column of `dp` based on the grid values and the previous cells in the same row or column.
+5. Iterate over each position `(i, j)` in the grid, starting from the second row and second column:
+   - Update `dp[i][j]` by adding the current grid value at `(i, j)` to the minimum of the values of the previous cells `(i-1, j)` and `(i, j-1)` in `dp`.
+6. Return `dp[m-1][n-1]`, which represents the minimum path sum from the top-left corner to the bottom-right corner of the grid.
+
+Here's the implementation of the `minPathSum` method in Swift:
+
+```swift
+class Solution {
+    func minPathSum(_ grid: [[Int]]) -> Int {
+        var matrix: [[Int]] = grid
+        let n = grid.count - 1
+        let m = grid[0].count - 1
+        
+        for i in 0...n {
+            for j in 0...m {
+                var step = matrix[i][j]
+        
+                if i > 0 && j > 0 {
+                    step += min(matrix[i - 1][j], matrix[i][j - 1])
+                } else if i > 0 && j == 0 {
+                    step += matrix[i - 1][j]
+                } else if j > 0 && i == 0 {
+                    step += matrix[i][j - 1]
+                }
+                
+                matrix[i][j] = step
+            }
+        }
+        
+        return matrix[n][m]
+    }
+}
+```
+
+This implementation efficiently calculates the minimum path sum using dynamic programming, with a time complexity of O(m * n) and a space complexity of O(m * n).

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

@@ -0,0 +1,65 @@
+[![](https://img.shields.io/github/stars/javadev/LeetCode-in-All?label=Stars&style=flat-square)](https://github.com/javadev/LeetCode-in-All)
+[![](https://img.shields.io/github/forks/javadev/LeetCode-in-All?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/javadev/LeetCode-in-All/fork)
+
+## 70\. Climbing Stairs
+
+Easy
+
+You are climbing a staircase. It takes `n` steps to reach the top.
+
+Each time you can either climb `1` or `2` steps. In how many distinct ways can you climb to the top?
+
+**Example 1:**
+
+**Input:** n = 2
+
+**Output:** 2
+
+**Explanation:** There are two ways to climb to the top. 1. 1 step + 1 step 2. 2 steps 
+
+**Example 2:**
+
+**Input:** n = 3
+
+**Output:** 3
+
+**Explanation:** There are three ways to climb to the top. 1. 1 step + 1 step + 1 step 2. 1 step + 2 steps 3. 2 steps + 1 step 
+
+**Constraints:**
+
+*   `1 <= n <= 45`
+
+To solve the "Climbing Stairs" problem in Swift with the Solution class, follow these steps:
+
+1. Define a method `climbStairs` in the `Solution` class that takes an integer `n` as input and returns the number of distinct ways to climb to the top of the staircase with `n` steps.
+2. Initialize an array `dp` of size `n+1` to store the number of distinct ways to reach each step.
+3. Set `dp[0] = 1` and `dp[1] = 1` since there is only one way to reach the first and second steps.
+4. Iterate over the steps from `2` to `n`:
+   - At each step `i`, the number of distinct ways to reach step `i` is the sum of the number of ways to reach steps `i-1` and `i-2`.
+   - Store this sum in `dp[i]`.
+5. Return `dp[n]`, which represents the number of distinct ways to climb to the top of the staircase with `n` steps.
+
+Here's the implementation of the `climbStairs` method in Swift:
+
+```swift
+public class Solution {
+    public func climbStairs(_ n: Int) -> Int {
+        if n < 2 {
+            return n
+        }
+        var cache = [Int](repeating: 0, count: n)
+        
+        // Initializing the base cases
+        cache[0] = 1
+        cache[1] = 2
+        
+        for i in 2..<n {
+            cache[i] = cache[i - 1] + cache[i - 2]
+        }
+        
+        return cache[n - 1]
+    }
+}
+```
+
+This implementation efficiently calculates the number of distinct ways to climb the stairs using dynamic programming, with a time complexity of O(n) and a space complexity of O(n).