Merge pull request #1884 from delight010/main

[SeongA] WEEK 07 solutions

Author: delight010

longest-substring-without-repeating-characters/delight010.swift

@@ -0,0 +1,26 @@
+class Solution {
+    // Time complexity O(N)
+    // Space complexity O(min(m,n))
+    func lengthOfLongestSubstring(_ s: String) -> Int {
+        if s.isEmpty {
+            return 0
+        }
+        var maxLength = 0
+        var startIndex = 0
+        var charSet: Set<Character> = []
+        let charArray = Array(s)
+        
+        for right in 0..<charArray.count {
+            while charSet.contains(charArray[right]) {
+                charSet.remove(charArray[startIndex])
+                startIndex += 1
+            }
+            
+            charSet.insert(charArray[right])
+            maxLength = max(maxLength, right - startIndex + 1)
+        }
+        
+        return maxLength
+    }
+}
+ 

reverse-linked-list/delight010.swift

@@ -0,0 +1,23 @@
+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 {
+    // Time complexity O(n)
+    // Space complexity O(1)
+    func reverseList(_ head: ListNode?) -> ListNode? {
+        var reverseList: ListNode? = nil
+        var currentHead = head
+        while let node = currentHead {
+            currentHead = node.next
+            node.next = reverseList
+            reverseList = node
+        }
+        return reverseList
+    }
+}
+ 

set-matrix-zeroes/delight010.swift

@@ -0,0 +1,63 @@
+class Solution {
+    // Time complexity O(MN)
+    // Space complexity O(1)
+    func setZeroes(_ matrix: inout [[Int]]) {
+        var firstRowHasZero = false
+        var firstColHasZero = false
+        
+        for col in 0..<matrix[0].count {
+            if matrix[0][col] == 0 {
+                firstRowHasZero = true
+                break
+            }
+        }
+        
+        for row in 0..<matrix.count {
+            if matrix[row][0] == 0 {
+                firstColHasZero = true
+                break
+            }
+        }
+        
+        // marking
+        for row in 0..<matrix.count {
+            for col in 0..<matrix[row].count {
+                if matrix[row][col] == 0 {
+                    matrix[row][0] = 0
+                    matrix[0][col] = 0
+                }
+            }
+        }
+        
+        // row
+        for row in 1..<matrix.count {
+            if matrix[row][0] == 0 {
+                for col in 0..<matrix[row].count {
+                    matrix[row][col] = 0
+                }
+            }
+        }
+        
+        // column
+        for col in 1..<matrix[0].count {
+            if matrix[0][col] == 0 {
+                for row in 0..<matrix.count {
+                    matrix[row][col] = 0
+                }
+            }
+        }
+        
+        if firstRowHasZero {
+            for col in 0..<matrix[0].count {
+                matrix[0][col] = 0
+            }
+        }
+        
+        if firstColHasZero {
+            for row in 0..<matrix.count {
+                matrix[row][0] = 0
+            }
+        }
+    }
+}
+ 

unique-paths/delight010.swift

@@ -0,0 +1,15 @@
+class Solution {
+    // Time complexity O(MN)
+    // Space complexity O(MN)
+    func uniquePaths(_ m: Int, _ n: Int) -> Int {
+        let column = Array(repeating: 1, count: n)
+        var grid: [[Int]] = Array(repeating: column, count: m)
+        for i in 1..<m {
+            for j in 1..<n {
+                grid[i][j] = grid[i - 1][j] + grid[i][j - 1]
+            }
+        }
+        return grid.last!.last!
+    }
+}
+