Added tasks 153-208

Author: javadev

README.md

@@ -39,12 +39,45 @@ Given a string `s` and a dictionary of strings `wordDict`, return `true` if `s`
 *   `s` and `wordDict[i]` consist of only lowercase English letters.
 *   All the strings of `wordDict` are **unique**.
 
-## Solution
+To solve the "Word Break" problem:
+
+The problem requires us to determine if a string `s` can be segmented into a sequence of words from a dictionary `wordDict`.
+
+### Steps to Approach:
+
+1. **Understanding the Problem:**
+   - We need to check if we can partition the string `s` such that each partition is a word from `wordDict`.
+   - The same word from `wordDict` can be reused multiple times.
+
+2. **Recursive Approach with Memoization:**
+   - We'll use a recursive function (`canBeBroken`) that will attempt to break down the string `s` starting from each index.
+   - Memoization (using `visited` array) helps avoid redundant computations by remembering if a substring starting from a particular index has already been processed.
+
+3. **Implementation Details:**
+
+   - **Initialization:** Convert each word in `wordDict` into an array of characters (`words`). Initialize `sSlice` as an array of characters from `s`.
+   - **Recursive Function (`canBeBroken`):**
+     - **Base Case:** If `startIndex` equals `chars.endIndex`, return `true`, indicating that the entire string has been successfully segmented.
+     - Check if `visited[startIndex]` is `true` to skip processing if the substring starting from `startIndex` has already been explored.
+     - Iterate through each word in `words`:
+       - Check if the current substring (`chars`) starts with the current `word`.
+       - If it does, recursively call `canBeBroken` with the remaining substring (`chars[startIndex.advanced(by: word.count)...]`).
+       - If the recursive call returns `true`, return `true` immediately.
+     - If no valid segmentation is found with any word, mark `visited[startIndex]` as `true` and return `false`.
+   - **Edge Cases:** Handle cases where `s` is empty or where no segmentation is possible with the given `wordDict`.
+
+4. **Complexity:** 
+   - Time complexity is influenced by both the length of `s` and the number of words in `wordDict`.
+   - Space complexity is primarily due to recursion depth and the `visited` array.
+
+### Swift Implementation:
+
+Here's the Swift implementation of the approach:
 
 ```swift
 class Solution {
     func wordBreak(_ s: String, _ wordDict: [String]) -> Bool {
-        var words = [[Character]]()
+        var words = \[\[Character]]()
         for word in wordDict {
             words.append(Array(word))
         }
@@ -61,17 +94,34 @@ class Solution {
         let startIndex = chars.startIndex
         guard startIndex != chars.endIndex else { return true }
         guard !visited[startIndex] else { return false }
+        
         for word in words {
-            guard 
-                chars.starts(with: word),
-                canBeBroken(chars[startIndex.advanced(by: word.count)...], words, &visited)
-            else { 
-                continue 
+            guard chars.starts(with: word) else { continue }
+            if canBeBroken(chars[startIndex.advanced(by: word.count)...], words, &visited) {
+                return true
             }
-            return true
         }
+        
         visited[startIndex] = true
         return false
     }
 }
-```
+```
+
+### Explanation of the Swift Code:
+
+- **Initialization (`wordBreak` function):**
+  - Convert each word in `wordDict` into arrays of characters (`words`).
+  - Convert the input string `s` into an array of characters (`sSlice`).
+  - Initialize a `visited` array to keep track of whether a substring starting from each index has been explored.
+
+- **Recursive Function (`canBeBroken`):**
+  - **Base Case:** If `startIndex` equals `chars.endIndex`, return `true`, indicating successful segmentation.
+  - Check if `visited[startIndex]` is `true` to avoid redundant computations.
+  - Iterate through each word in `words`:
+    - Check if the current substring (`chars`) starts with the current `word`.
+    - If true, recursively call `canBeBroken` with the remaining substring (`chars[startIndex.advanced(by: word.count)...]`).
+    - If the recursive call returns `true`, immediately return `true`.
+  - If no valid segmentation is found, mark `visited[startIndex]` as `true` and return `false`.
+
+This approach ensures that we explore all possible ways to segment `s` using words from `wordDict` while efficiently handling overlapping subproblems using memoization.

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

@@ -49,35 +49,74 @@ Return `true` _if there is a cycle in the linked list_. Otherwise, return `false
 
 **Follow up:** Can you solve it using `O(1)` (i.e. constant) memory?
 
-## Solution
+To solve the "Linked List Cycle" problem, we can use the Floyd's Tortoise and Hare algorithm. This algorithm uses two pointers moving at different speeds to detect if a cycle exists in the linked list. Here’s a step-by-step guide and the Swift implementation of the solution.
 
-```swift
-/**
- * Definition for singly-linked list.
- * public class ListNode {
- *     public var val: Int
- *     public var next: ListNode?
- *     public init(_ val: Int) {
- *         self.val = val
- *         self.next = nil
- *     }
- * }
- */
-class Solution {
-    func hasCycle(_ head: ListNode?) -> Bool {
+### Steps to Solve the Problem
+
+1. **Initialization:**
+   - Define two pointers, `slow` and `fast`, both starting at the head of the linked list.
+
+2. **Traversal and Cycle Detection:**
+   - Move the `slow` pointer one step at a time.
+   - Move the `fast` pointer two steps at a time.
+   - If there is a cycle, the `fast` pointer will eventually meet the `slow` pointer.
+   - If the `fast` pointer reaches the end of the list (i.e., `fast` or `fast.next` becomes `nil`), there is no cycle in the linked list.
 
-       var slow = head
-       var fast = head
+3. **Return Result:**
+   - If the `fast` pointer meets the `slow` pointer, return `true` indicating a cycle.
+   - If the `fast` pointer reaches the end, return `false`.
 
-       while fast != nil && fast?.next != nil {
-        slow = slow?.next
-        fast = fast?.next?.next
+### Swift Implementation
 
-        if slow === fast {
-            return true
+Here’s the implementation of the `Solution` class using the Floyd's Tortoise and Hare algorithm:
+
+```swift
+// Definition for singly-linked list.
+class ListNode {
+    var val: Int
+    var next: ListNode?
+    init(_ val: Int) {
+        self.val = val
+        self.next = nil
+    }
+}
+
+class Solution {
+    func hasCycle(_ head: ListNode?) -> Bool {
+        // Initialize slow and fast pointers
+        var slow = head
+        var fast = head
+        
+        // Traverse the linked list
+        while fast != nil && fast?.next != nil {
+            slow = slow?.next         // Move slow pointer one step
+            fast = fast?.next?.next   // Move fast pointer two steps
+            
+            // Check if slow and fast pointers meet
+            if slow === fast {
+                return true
+            }
         }
-       }
-       return false 
+        
+        // If we reach here, there is no cycle
+        return false
     }
 }
-```
+```
+
+### Explanation of the Swift Code
+
+1. **Initialization:**
+   - The `ListNode` class defines the structure of a node in the linked list.
+   - The `Solution` class contains the `hasCycle` method which checks for a cycle.
+
+2. **Traversal and Cycle Detection:**
+   - The `while` loop continues as long as `fast` and `fast?.next` are not `nil`.
+   - The `slow` pointer is moved one step (`slow = slow?.next`).
+   - The `fast` pointer is moved two steps (`fast = fast?.next?.next`).
+
+3. **Cycle Detection:**
+   - If the `slow` pointer and `fast` pointer meet (`if slow === fast`), it indicates there is a cycle, and the method returns `true`.
+   - If the loop exits because `fast` or `fast?.next` is `nil`, it means there is no cycle, and the method returns `false`.
+
+This approach ensures that we use constant space (`O(1)`) while efficiently detecting the presence of a cycle in the linked list.

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

@@ -49,48 +49,86 @@ There is a cycle in a linked list if there is some node in the list that can be
 
 **Follow up:** Can you solve it using `O(1)` (i.e. constant) memory?
 
-## Solution
+To solve the "Linked List Cycle II" problem, we need to find the node where the cycle begins in a linked list, if there is a cycle. We'll use Floyd's Tortoise and Hare algorithm to detect the cycle and then determine the starting node of the cycle.
+
+### Steps to Solve the Problem
+
+1. **Cycle Detection:**
+   - Use two pointers, `slow` and `fast`, to detect if a cycle exists. Both pointers start at the head of the linked list.
+   - Move `slow` one step at a time and `fast` two steps at a time.
+   - If `slow` and `fast` meet, a cycle exists.
+
+2. **Finding the Start of the Cycle:**
+   - If a cycle is detected, initialize another pointer, `start`, at the head of the list.
+   - Move both `start` and `slow` one step at a time.
+   - The point where they meet is the start of the cycle.
+
+3. **Return Result:**
+   - If no cycle is detected, return `nil`.
+   - If a cycle is detected, return the node where `start` and `slow` meet.
+
+### Swift Implementation
+
+Here’s the Swift implementation of the `Solution` class:
 
 ```swift
-/**
- * Definition for singly-linked list.
- * public class ListNode {
- *     public var val: Int
- *     public var next: ListNode?
- *     public init(_ val: Int) {
- *         self.val = val
- *         self.next = nil
- *     }
- * }
- */
+// Definition for singly-linked list.
+class ListNode {
+    var val: Int
+    var next: ListNode?
+    init(_ val: Int) {
+        self.val = val
+        self.next = nil
+    }
+}
+
 class Solution {
     func detectCycle(_ head: ListNode?) -> ListNode? {
-        if head == nil || head?.next == nil {
-            return nil
-        }
-
+        guard head != nil else { return nil }
+        
         var slow = head
         var fast = head
-
+        
+        // Cycle detection
         while fast != nil && fast?.next != nil {
-            fast = fast?.next?.next
             slow = slow?.next
-
+            fast = fast?.next?.next
+            
             if slow === fast {
-                break
+                // Cycle detected, now find the start of the cycle
+                var start = head
+                while start !== slow {
+                    start = start?.next
+                    slow = slow?.next
+                }
+                return start
             }
         }
-
-        if fast == nil || fast?.next == nil {
-            return nil
-        }
-
-        slow = head
-        while slow !== fast {
-            slow = slow?.next
-            fast = fast?.next
-        }
-        return slow
+        
+        // No cycle detected
+        return nil
     }
 }
-```
+```
+
+### Explanation of the Swift Code
+
+1. **Initialization:**
+   - The `ListNode` class defines the structure of a node in the linked list.
+   - The `Solution` class contains the `detectCycle` method which finds the start of the cycle if it exists.
+
+2. **Cycle Detection:**
+   - Initialize `slow` and `fast` pointers to the head of the linked list.
+   - Use a `while` loop to move `slow` one step and `fast` two steps at a time.
+   - If `slow` and `fast` meet, a cycle is detected.
+
+3. **Finding the Start of the Cycle:**
+   - If a cycle is detected, initialize `start` at the head of the list.
+   - Move both `start` and `slow` one step at a time until they meet.
+   - The meeting point is the start of the cycle.
+
+4. **Return Result:**
+   - If no cycle is detected, the function returns `nil`.
+   - If a cycle is detected, the function returns the node where `start` and `slow` meet.
+
+This approach ensures that we detect the cycle efficiently and find the starting node of the cycle using constant space (`O(1)` memory), adhering to the problem constraints.