Merge pull request #1410 from doitduri/main

[doitduri] Week 05 Solution

Author: doitduri

best-time-to-buy-and-sell-stock/doitduri.swift

@@ -0,0 +1,18 @@
+class Solution {
+    func maxProfit(_ prices: [Int]) -> Int {
+        guard var anchor = prices.first, prices.count > 1 else {
+            return 0
+        }
+        
+        var result = 0
+        for price in prices {
+            if price < anchor {
+                anchor = price
+            } else if price - anchor > result {
+                result = price - anchor
+            }
+        }
+        
+        return result
+    }
+}

group-anagrams/doitduri.swift

@@ -0,0 +1,16 @@
+class Solution {
+    func groupAnagrams(_ strs: [String]) -> [[String]] {
+        var groups: [String: [String]] = [:]
+        
+        for str in strs {
+            let sortedStr = String(str.sorted())
+            
+            var values = groups[sortedStr] ?? []
+            values.append(str)
+            
+            groups[sortedStr] = values
+        }
+        
+        return Array(groups.values)
+    }
+}

implement-trie-prefix-tree/doitduri.swift

@@ -0,0 +1,46 @@
+class TrieNode {
+    var children: [Character: TrieNode] = [:]
+    var isEnd: Bool = false
+}
+
+class Trie {
+    private let root: TrieNode
+    
+    init() {
+        root = TrieNode()
+    }
+    
+    func insert(_ word: String) {
+        var current = root
+        for char in word {
+            if current.children[char] == nil {
+                current.children[char] = TrieNode()
+            }
+            current = current.children[char]!
+        }
+        current.isEnd = true
+    }
+    
+    func search(_ word: String) -> Bool {
+        guard let node = findNode(word) else {
+            return false
+        }
+        return node.isEnd
+    }
+    
+    func startsWith(_ prefix: String) -> Bool {
+        return findNode(prefix) != nil
+    }
+    
+    private func findNode(_ prefix: String) -> TrieNode? {
+        var current = root
+        for char in prefix {
+            guard let next = current.children[char] else {
+                return nil
+            }
+            current = next
+        }
+        return current
+    }
+}
+

word-break/doitduri.swift

@@ -0,0 +1,26 @@
+class Solution {
+    func wordBreak(_ s: String, _ wordDict: [String]) -> Bool {
+        let wordSet = Set(wordDict)
+        var dp = Array(repeating: false, count: s.count + 1)
+        
+        dp[0] = true
+        
+        for i in 1...s.count {
+            for j in 0..<i {
+                
+                guard dp[j] else { continue }
+                
+                let startIndex = s.index(s.startIndex, offsetBy: j)
+                let endIndex = s.index(s.startIndex, offsetBy: i)
+                let word = String(s[startIndex..<endIndex])
+                
+                if wordSet.contains(word) {
+                    dp[i] = true
+                    break
+                }
+            }
+        }
+        
+        return dp[s.count]
+    }
+}