Merge pull request #1432 from doitduri/main

[doitduri] WEEK 06 solutions

Author: doitduri

container-with-most-water/doitduri.swift

@@ -0,0 +1,22 @@
+class Solution {
+    func maxArea(_ height: [Int]) -> Int {
+        var start = 0
+        var end = height.count - 1
+        var result = 0
+        
+        while start < end {
+            let width = end - start
+            let waters = width * (min(height[start], height[end]))
+            
+            result = max(result, waters)
+            
+            if height[start] > height[end] {
+                end  = end - 1
+            } else {
+                start = start + 1
+            }
+        }
+        
+        return result
+    }
+}

design-add-and-search-words-data-structure/doitduri.swift

@@ -0,0 +1,57 @@
+class WordDictionary {
+    class TrieNode {
+        var children: [Character: TrieNode] = [:]
+        var isEndOfWord: Bool = false
+    }
+    
+    private let root: TrieNode
+    
+    init() {
+        root = TrieNode()
+    }
+    
+    func addWord(_ word: String) {
+        let key = word.lowercased()
+        var current = root
+        
+        for char in key {
+            if current.children[char] == nil {
+                current.children[char] = TrieNode()
+            }
+            
+            if let node = current.children[char] {
+                current = node
+            }
+        }
+        
+        current.isEndOfWord = true
+    }
+    
+    func search(_ word: String) -> Bool {
+        let key = word.lowercased()
+        return searchInNode(Array(key), 0, root)
+    }
+    
+    private func searchInNode(_ word: [Character], _ index: Int, _ node: TrieNode) -> Bool {
+        if index == word.count {
+            return node.isEndOfWord
+        }
+        
+        let currentChar = word[index]
+        
+        if currentChar == "." {
+            for (_, childNode) in node.children {
+                if searchInNode(word, index + 1, childNode) {
+                    return true
+                }
+            }
+            return false
+        } else {
+            guard let nextNode = node.children[currentChar] else {
+                return false
+            }
+            
+            return searchInNode(word, index + 1, nextNode)
+        }
+    }
+}

longest-increasing-subsequence/doitduri.swift

@@ -0,0 +1,20 @@
+class Solution {
+    func lengthOfLIS(_ nums: [Int]) -> Int {
+        if nums.isEmpty {
+            return 0
+        }
+        
+        let n = nums.count
+        var dp = Array(repeating: 1, count: n)
+        
+        for i in 1..<n {
+            for j in 0..<i {
+                if nums[i] > nums[j] {
+                    dp[i] = max(dp[i], dp[j] + 1)
+                }
+            }
+        }
+        
+        return dp.max() ?? 1
+    }
+}

spiral-matrix/doitduri.swift

@@ -0,0 +1,42 @@
+class Solution {
+    func spiralOrder(_ matrix: [[Int]]) -> [Int] {
+        guard !matrix.isEmpty else { return [] }
+        
+        var answer: [Int] = []
+        
+        var top = 0
+        var bottom = matrix.count - 1
+        var left = 0
+        var right = matrix[0].count - 1
+        
+        while top <= bottom && left <= right {
+            for i in left...right {
+                answer.append(matrix[top][i])
+            }
+            top += 1
+            
+            if top <= bottom {
+                for i in top...bottom {
+                    answer.append(matrix[i][right])
+                }
+            }
+            right -= 1
+            
+            if top <= bottom && left <= right {
+                for i in stride(from: right, through: left, by: -1) {
+                    answer.append(matrix[bottom][i])
+                }
+                bottom -= 1
+            }
+            
+            if left <= right && top <= bottom {
+                for i in stride(from: bottom, through: top, by: -1) {
+                    answer.append(matrix[i][left])
+                }
+                left += 1
+            }
+        }
+        
+        return answer
+    }
+}

valid-parentheses/doitduri.swift

@@ -0,0 +1,23 @@
+class Solution {
+    func isValid(_ s: String) -> Bool {
+        let pair: [Character: Character] = [
+            "(": ")",
+            "[": "]",
+            "{": "}"
+        ]
+        
+        var stack: [Character] = []
+        
+        for char in s {
+            if pair.keys.contains(char) {
+                stack.append(char)
+            } else {
+                if stack.isEmpty || pair[stack.removeLast()] != char {
+                    return false
+                }
+            }
+        }
+        
+        return stack.isEmpty
+    }
+}