Added tasks 1-39

Author: javadev

README.md

@@ -0,0 +1,107 @@
+[![](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)
+
+## 1\. Two Sum
+
+Easy
+
+Given an array of integers `nums` and an integer `target`, return _indices of the two numbers such that they add up to `target`_.
+
+You may assume that each input would have **_exactly_ one solution**, and you may not use the _same_ element twice.
+
+You can return the answer in any order.
+
+**Example 1:**
+
+**Input:** nums = [2,7,11,15], target = 9
+
+**Output:** [0,1]
+
+**Explanation:** Because nums[0] + nums[1] == 9, we return [0, 1]. 
+
+**Example 2:**
+
+**Input:** nums = [3,2,4], target = 6
+
+**Output:** [1,2] 
+
+**Example 3:**
+
+**Input:** nums = [3,3], target = 6
+
+**Output:** [0,1] 
+
+**Constraints:**
+
+*   <code>2 <= nums.length <= 10<sup>4</sup></code>
+*   <code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code>
+*   <code>-10<sup>9</sup> <= target <= 10<sup>9</sup></code>
+*   **Only one valid answer exists.**
+
+**Follow-up:** Can you come up with an algorithm that is less than <code>O(n<sup>2</sup>)</code> time complexity?
+
+To solve the "Two Sum" problem in Swift using a `Solution` class, follow these steps:
+
+1. **Understand the problem:** You need to find two indices in the array `nums` such that the numbers at those indices add up to `target`. Each input has exactly one solution, and the same element cannot be used twice.
+
+2. **Plan your approach:** 
+    - Use a dictionary to store the difference between the target and each number in the array. This dictionary will help in checking if the complement of the current number (i.e., `target - nums[i]`) has been seen before.
+    - Iterate through the array, and for each element, check if it exists in the dictionary.
+    - If it exists, return the indices of the current element and the stored element.
+    - If it does not exist, add the element and its index to the dictionary.
+
+3. **Implement the solution:**
+    - Define the `Solution` class and the `twoSum` method.
+    - Use a dictionary to keep track of the numbers and their indices.
+    - Iterate through the array and perform the necessary checks and updates.
+
+Here is the Swift implementation of the solution:
+
+```swift
+class Solution {
+    func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
+        // Create a dictionary to store the number and its index
+        var numDict = [Int: Int]()
+        
+        // Iterate through the nums array
+        for (index, num) in nums.enumerated() {
+            // Calculate the complement
+            let complement = target - num
+            
+            // Check if the complement exists in the dictionary
+            if let complementIndex = numDict[complement] {
+                // If found, return the indices
+                return [complementIndex, index]
+            }
+            
+            // Otherwise, add the current number and its index to the dictionary
+            numDict[num] = index
+        }
+        
+        // In case no solution is found (which shouldn't happen as per problem constraints)
+        return []
+    }
+}
+
+// Example usage:
+let solution = Solution()
+let nums1 = [2, 7, 11, 15]
+let target1 = 9
+print(solution.twoSum(nums1, target1))  // Output: [0, 1]
+
+let nums2 = [3, 2, 4]
+let target2 = 6
+print(solution.twoSum(nums2, target2))  // Output: [1, 2]
+
+let nums3 = [3, 3]
+let target3 = 6
+print(solution.twoSum(nums3, target3))  // Output: [0, 1]
+```
+
+### Explanation:
+- **Dictionary (`numDict`):** This dictionary keeps track of each number and its index as we iterate through the array.
+- **Iteration:** For each number in the array, calculate the complement (`target - num`).
+- **Check:** If the complement is already in the dictionary, return the indices of the complement and the current number.
+- **Update:** If not, add the current number and its index to the dictionary and continue.
+
+This approach ensures that the solution has a time complexity of \(O(n)\), which is efficient for large input sizes.

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

@@ -0,0 +1,82 @@
+[![](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)
+
+## 2\. Add Two Numbers
+
+Medium
+
+You are given two **non-empty** linked lists representing two non-negative integers. The digits are stored in **reverse order**, and each of their nodes contains a single digit. Add the two numbers and return the sum as a linked list.
+
+You may assume the two numbers do not contain any leading zero, except the number 0 itself.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/10/02/addtwonumber1.jpg)
+
+**Input:** l1 = [2,4,3], l2 = [5,6,4]
+
+**Output:** [7,0,8]
+
+**Explanation:** 342 + 465 = 807. 
+
+**Example 2:**
+
+**Input:** l1 = [0], l2 = [0]
+
+**Output:** [0] 
+
+**Example 3:**
+
+**Input:** l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
+
+**Output:** [8,9,9,9,0,0,0,1] 
+
+**Constraints:**
+
+*   The number of nodes in each linked list is in the range `[1, 100]`.
+*   `0 <= Node.val <= 9`
+*   It is guaranteed that the list represents a number that does not have leading zeros.
+
+To solve the Add Two Numbers problem in Swift using a `Solution` class, we'll follow these steps:
+
+1. Define a `ListNode` class to represent nodes in a linked list.
+2. Define a `Solution` class with a method named `addTwoNumbers`.
+3. Inside the `addTwoNumbers` method, traverse both input linked lists simultaneously:
+   - Keep track of a carry variable to handle cases where the sum of two digits exceeds 9.
+   - Calculate the sum of the current nodes' values along with the carry.
+   - Update the carry for the next iteration.
+   - Create a new node with the sum % 10 and attach it to the result linked list.
+   - Move to the next nodes in both input lists.
+4. After finishing the traversal, check if there is any remaining carry. If so, add a new node with the carry to the result.
+5. Return the head of the result linked list.
+
+Here's the implementation:
+
+```swift
+/*
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     public var val: Int
+ *     public var next: ListNode?
+ *     public init() { self.val = 0; self.next = nil; }
+ *     public init(_ val: Int) { self.val = val; self.next = nil; }
+ *     public init(_ val: Int, _ next: ListNode?) { self.val = val; self.next = next; }
+ * }
+ */
+class Solution {
+    
+    func addTwoNumbers(_ l1: ListNode?, _ l2: ListNode?) -> ListNode? {
+        return addNumbers(l1, l2, 0)
+    }
+
+    func addNumbers(_ l1: ListNode?, _ l2: ListNode?, _ carryOver: Int) -> ListNode? {
+        guard !(l1 == nil && l2 == nil && carryOver == 0 ) else { return nil }
+        let sum = ( l1?.val ?? 0 ) + ( l2?.val ?? 0 ) + carryOver 
+        let carryOver = sum / 10 
+        let value = sum % 10 
+        return ListNode(value, addNumbers(l1?.next, l2?.next, carryOver))
+    }
+}
+```
+
+This implementation provides a solution to the Add Two Numbers problem using linked lists in Swift.

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

@@ -0,0 +1,87 @@
+[![](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)
+
+## 3\. Longest Substring Without Repeating Characters
+
+Medium
+
+Given a string `s`, find the length of the **longest substring** without repeating characters.
+
+**Example 1:**
+
+**Input:** s = "abcabcbb"
+
+**Output:** 3
+
+**Explanation:** The answer is "abc", with the length of 3. 
+
+**Example 2:**
+
+**Input:** s = "bbbbb"
+
+**Output:** 1
+
+**Explanation:** The answer is "b", with the length of 1. 
+
+**Example 3:**
+
+**Input:** s = "pwwkew"
+
+**Output:** 3
+
+**Explanation:** The answer is "wke", with the length of 3. Notice that the answer must be a substring, "pwke" is a subsequence and not a substring. 
+
+**Example 4:**
+
+**Input:** s = ""
+
+**Output:** 0 
+
+**Constraints:**
+
+*   <code>0 <= s.length <= 5 * 10<sup>4</sup></code>
+*   `s` consists of English letters, digits, symbols and spaces.
+
+To solve the Longest Substring Without Repeating Characters problem in Swift using a `Solution` class, we'll follow these steps:
+
+1. Define a `Solution` class with a method named `lengthOfLongestSubstring`.
+2. Initialize variables to keep track of the starting index of the substring (`start`), the maximum length (`maxLen`), and a hashmap to store characters and their indices.
+3. Iterate through the string `s`, and for each character:
+   - Check if the character exists in the hashmap and its index is greater than or equal to the `start` index.
+   - If found, update the `start` index to the index after the last occurrence of the character.
+   - Update the maximum length if necessary.
+   - Update the index of the current character in the hashmap.
+4. Return the maximum length found.
+5. Handle the edge case where the input string is empty.
+
+Here's the implementation:
+
+```swift
+public class Solution {
+    public func lengthOfLongestSubstring(_ s: String) -> Int {
+        var lastIndices = Array(repeating: -1, count: 256)
+        var maxLen = 0
+        var curLen = 0
+        var start = 0
+
+        for (i, char) in s.enumerated() {
+            let asciiValue = Int(char.asciiValue!)
+            if lastIndices[asciiValue] < start {
+                lastIndices[asciiValue] = i
+                curLen += 1
+            } else {
+                let lastIndex = lastIndices[asciiValue]
+                start = lastIndex + 1
+                curLen = i - start + 1
+                lastIndices[asciiValue] = i
+            }
+            if curLen > maxLen {
+                maxLen = curLen
+            }
+        }
+        return maxLen
+    }
+}
+```
+
+This implementation provides a solution to the Longest Substring Without Repeating Characters problem in Swift.

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

@@ -0,0 +1,107 @@
+[![](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)
+
+## 4\. Median of Two Sorted Arrays
+
+Hard
+
+Given two sorted arrays `nums1` and `nums2` of size `m` and `n` respectively, return **the median** of the two sorted arrays.
+
+The overall run time complexity should be `O(log (m+n))`.
+
+**Example 1:**
+
+**Input:** nums1 = [1,3], nums2 = [2]
+
+**Output:** 2.00000
+
+**Explanation:** merged array = [1,2,3] and median is 2. 
+
+**Example 2:**
+
+**Input:** nums1 = [1,2], nums2 = [3,4]
+
+**Output:** 2.50000
+
+**Explanation:** merged array = [1,2,3,4] and median is (2 + 3) / 2 = 2.5. 
+
+**Example 3:**
+
+**Input:** nums1 = [0,0], nums2 = [0,0]
+
+**Output:** 0.00000 
+
+**Example 4:**
+
+**Input:** nums1 = [], nums2 = [1]
+
+**Output:** 1.00000 
+
+**Example 5:**
+
+**Input:** nums1 = [2], nums2 = []
+
+**Output:** 2.00000 
+
+**Constraints:**
+
+*   `nums1.length == m`
+*   `nums2.length == n`
+*   `0 <= m <= 1000`
+*   `0 <= n <= 1000`
+*   `1 <= m + n <= 2000`
+*   <code>-10<sup>6</sup> <= nums1[i], nums2[i] <= 10<sup>6</sup></code>
+
+To solve the Median of Two Sorted Arrays problem in Swift using a `Solution` class, we'll follow these steps:
+
+1. Define a `Solution` class with a method named `findMedianSortedArrays`.
+2. Calculate the total length of the combined array (m + n).
+3. Determine the middle index or indices of the combined array based on its length (for both even and odd lengths).
+4. Implement a binary search algorithm to find the correct position for partitioning the two arrays such that elements to the left are less than or equal to elements on the right.
+5. Calculate the median based on the partitioned arrays.
+6. Handle edge cases where one or both arrays are empty or where the combined length is odd or even.
+7. Return the calculated median.
+
+Here's the implementation:
+
+```swift
+public class Solution {
+    public func findMedianSortedArrays(_ nums1: [Int], _ nums2: [Int]) -> Double {
+        let n1 = nums1.count
+        let n2 = nums2.count
+        
+        if n1 > n2 {
+            return findMedianSortedArrays(nums2, nums1)
+        }
+        
+        var low = 0
+        var high = n1
+        
+        while low <= high {
+            let cut1 = (low + high) / 2
+            let cut2 = (n1 + n2 + 1) / 2 - cut1
+            
+            let l1 = cut1 == 0 ? Int.min : nums1[cut1 - 1]
+            let l2 = cut2 == 0 ? Int.min : nums2[cut2 - 1]
+            let r1 = cut1 == n1 ? Int.max : nums1[cut1]
+            let r2 = cut2 == n2 ? Int.max : nums2[cut2]
+            
+            if l1 <= r2 && l2 <= r1 {
+                if (n1 + n2) % 2 == 0 {
+                    return (Double(max(l1, l2)) + Double(min(r1, r2))) / 2.0
+                } else {
+                    return Double(max(l1, l2))
+                }
+            } else if l1 > r2 {
+                high = cut1 - 1
+            } else {
+                low = cut1 + 1
+            }
+        }
+        
+        return 0.0
+    }
+}
+```
+
+This implementation provides a solution to the Median of Two Sorted Arrays problem in Swift with a runtime complexity of O(log(min(m, n))).