Improved tasks 200 and 560

Author: javadev

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

@@ -45,34 +45,34 @@ An **island** is surrounded by water and is formed by connecting adjacent lands
 ## Solution
 
 ```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 reverseList(_ head: ListNode?) -> ListNode? {
-        var prev: ListNode? = nil
-        var curr = head
-        var next = head?.next
-
-        while curr != nil {
-
-            // reverse the current nodes link
-            curr?.next = prev
-            
-            // update variables
-            prev = curr
-            curr = next
-            next = next?.next
+    func numIslands(_ grid: [[Character]]) -> Int {
+        var grid = grid
+        var islands = 0
+
+        if !grid.isEmpty && !grid[0].isEmpty {
+            for i in 0..<grid.count {
+                for j in 0..<grid[0].count {
+                    if grid[i][j] == "1" {
+                        dfs(&grid, i, j)
+                        islands += 1
+                    }
+                }
+            }
+        }
+        return islands
+    }
+
+    private func dfs(_ grid: inout [[Character]], _ x: Int, _ y: Int) {
+        if x < 0 || x >= grid.count || y < 0 || y >= grid[0].count || grid[x][y] != "1" {
+            return
         }
 
-        return prev
+        grid[x][y] = "x"
+        dfs(&grid, x + 1, y)
+        dfs(&grid, x - 1, y)
+        dfs(&grid, x, y + 1)
+        dfs(&grid, x, y - 1)
     }
 }
 ```

src/main/swift/g0501_0600/s0560_subarray_sum_equals_k/readme.md

@@ -30,20 +30,19 @@ Given an array of integers `nums` and an integer `k`, return _the total number o
 ```swift
 class Solution {
     func subarraySum(_ nums: [Int], _ k: Int) -> Int {
-       var result = 0
-    var dict = [Int: Int]()
-    dict[0] = 1
+        var result = 0
+        var dict = [Int: Int]()
+        dict[0] = 1
 
-    var sum = 0
-    for num in nums {
-        sum += num
-        if let val = dict[sum - k] {
-            result += val
+        var sum = 0
+        for num in nums {
+            sum += num
+            if let val = dict[sum - k] {
+                result += val
+            }
+            dict[sum, default: 0] += 1
         }
-        dict[sum, default: 0] += 1
-        }
-
-     return result 
+        return result 
     }
 }
 ```