solve : week 1 with swift

Author: changmuk.im

contains-duplicate/EGON.swift

@@ -0,0 +1,34 @@
+import Foundation
+
+class Solution {
+    func containsDuplicate(_ nums: [Int]) -> Bool {
+        return solve_2(nums)
+    }
+    
+    /*
+         Runtime: 246 ms (Beats 68.44%)
+         Analyze Complexity: O(n)
+         Memory: 19.94 MB (Beats 76.01%)
+     */
+    func solve_1(_ nums: [Int]) -> Bool {
+        return nums.count != Set(nums).count
+    }
+    
+    /*
+         Runtime: 240 ms (Beats 90.56%)
+         Analyze Complexity: O(n)
+         Memory: 22.56 MB (Beats 33.43%)
+     */
+    func solve_2(_ nums: [Int]) -> Bool {
+        var counter: [Int: Bool] = [:]
+        for num in nums {
+            if counter[num] != nil {
+                return true
+            } else {
+                counter[num] = true
+            }
+        }
+        
+        return false
+    }
+}

kth-smallest-element-in-a-bst/EGON.swift

@@ -0,0 +1,41 @@
+import Foundation
+
+public class TreeNode {
+    public var val: Int
+    public var left: TreeNode?
+    public var right: TreeNode?
+    public init() { self.val = 0; self.left = nil; self.right = nil; }
+    public init(_ val: Int) { self.val = val; self.left = nil; self.right = nil; }
+    public init(_ val: Int, _ left: TreeNode?, _ right: TreeNode?) {
+        self.val = val
+        self.left = left
+        self.right = right
+    }
+}
+
+class Solution {
+    
+    /*
+        Runtime: 28 ms (Beats 46.95%)
+        Analyze Complexity: O(n)
+        Memory: 16.52 MB (Beats 53.05%)
+    */
+    func kthSmallest(_ root: TreeNode?, _ k: Int) -> Int {
+        func inorderTraverse(_ root: TreeNode?, _ k: Int) {
+            guard let root = root, visited.count < k else {
+                return
+            }
+            
+            inorderTraverse(root.left, k)
+            if visited.count < k {
+                visited.append(root.val)
+            }
+            inorderTraverse(root.right, k)
+        }
+        
+        var visited: [Int] = []
+        inorderTraverse(root, k)
+
+        return visited[k - 1]
+    }
+}

number-of-1-bits/EGON.swift

@@ -0,0 +1,32 @@
+import Foundation
+
+class Solution {
+    func hammingWeight(_ n: Int) -> Int {
+        return solve_2(n)
+    }
+    
+    /*
+        Runtime: 5 ms (Beats 38.73%)
+        Analyze Complexity: O(k), k는 2진수의 1의 갯수
+        Memory: 14.88 MB (Beats 98.27%)
+     */
+    func solve_1(_ n: Int) -> Int {
+        return n.nonzeroBitCount
+    }
+    
+    /*
+        Runtime: 3 ms (Beats 65.90%)
+        Analyze Complexity: O(k), k는 2진수의 1의 갯수
+        Memory: 15.08 MB (Beats 89.02%)
+     */
+    func solve_2(_ n: Int) -> Int {
+        var num = n
+        var hammingWeight = 0
+        while 0 < num {
+            num &= num - 1
+            hammingWeight += 1
+        }
+        
+        return hammingWeight
+    }
+}

palindromic-substrings/EGON.swift

@@ -0,0 +1,92 @@
+import Foundation
+
+class Solution {
+    func countSubstrings(_ s: String) -> Int {
+        return solve_2(s)
+    }
+    
+    /*
+         Runtime: 507 ms (Beats 5.07%)
+         Analyze Complexity: O(n ** 3)
+         Memory: 16.07 MB (Beats 80.43%)
+     */
+    func solve_1(_ s: String) -> Int {
+        let sArray = Array(s)
+        var count = 0
+        for left in 0..<s.count {
+            for right in left..<s.count {
+                var isPalindrome = false
+                for step in 0...(right-left) {
+                    if sArray[left + step] != sArray[right - step] {
+                        isPalindrome = true
+                        break
+                    }
+                }
+
+                count += isPalindrome ? 1 : 0
+            }
+        }
+        
+        return count
+    }
+    
+    /*
+         Runtime: 8 ms (Beats 37.68%)
+         Analyze Complexity: O(n ** 2)
+         Memory: 16.14 MB (Beats 72.46%)
+     */
+    func solve_2(_ s: String) -> Int {
+        let sArray = Array(s)
+        let n = sArray.count
+        var count = 0
+        
+        for center in 0..<(2 * n - 1) {
+            var left = center / 2
+            var right = left + (center % 2)
+            
+            while 0 <= left && right < n && sArray[left] == sArray[right] {
+                count += 1
+                left -= 1
+                right += 1
+            }
+        }
+        
+        return count
+    }
+    
+    /*
+         Runtime: 14 ms (Beats 30.43%)
+         Analyze Complexity: O(n ** 2)
+         Memory: 16.85 MB (Beats 13.04%)
+     */
+    func solve_3(_ s: String) -> Int {
+        let sArray = Array(s)
+        let n = sArray.count
+        var dp = Array(repeating: Array(repeating: false, count: n), count: n)
+        var count = 0
+        
+        for i in 0..<n {
+            dp[i][i] = true
+            count += 1
+        }
+        
+        for i in 0..<(n - 1) {
+            dp[i][i + 1] = sArray[i] == sArray[i + 1]
+            count += dp[i][i + 1] == true ? 1 : 0
+        }
+        
+        if n < 3 {
+            return count
+        }
+        
+        for length in 3..<(n + 1) {
+            for left in 0..<(n - length + 1) {
+                let right = left + length - 1
+                dp[left][right] = dp[left + 1][right - 1] == true && sArray[left] == sArray[right]
+                count += dp[left][right] == true ? 1 : 0
+            }
+        }
+        
+        return count
+    }
+}

top-k-frequent-elements/EGON.swift

@@ -0,0 +1,118 @@
+import Foundation
+
+final class MaxHeap<T: Comparable> {
+    private var heap: [T] = []
+    
+    func insert(_ value: T) {
+        heap.append(value)
+        heapifyUp(from: heap.count - 1)
+    }
+    
+    @discardableResult
+    func pop() -> T? {
+        guard !heap.isEmpty else {
+            return nil
+        }
+        
+        if heap.count == 1 {
+            return heap.removeLast()
+        }
+        
+        let removedValue = heap[0]
+        heap[0] = heap.removeLast()
+        heapifyDown(from: 0)
+        
+        return removedValue
+    }
+}
+
+private extension MaxHeap {
+    private func parentIndex(of index: Int) -> Int {
+        return (index - 1) / 2
+    }
+    
+    private func leftChildIndex(of index: Int) -> Int {
+        return 2 * index + 1
+    }
+    
+    private func rightChildIndex(of index: Int) -> Int {
+        return 2 * index + 2
+    }
+    
+    private func heapifyUp(from index: Int) {
+        var currentIndex = index
+        while currentIndex > 0 {
+            let parentIdx = parentIndex(of: currentIndex)
+            if heap[currentIndex] > heap[parentIdx] {
+                heap.swapAt(currentIndex, parentIdx)
+                currentIndex = parentIdx
+            } else {
+                break
+            }
+        }
+    }
+    
+    private func heapifyDown(from index: Int) {
+        var oldIndex = index
+        let count = heap.count
+        
+        while true {
+            let leftIndex = leftChildIndex(of: oldIndex)
+            let rightIndex = rightChildIndex(of: oldIndex)
+            var newIndex = oldIndex
+            
+            if leftIndex < count && heap[leftIndex] > heap[newIndex] {
+                newIndex = leftIndex
+            }
+            
+            if rightIndex < count && heap[rightIndex] > heap[newIndex] {
+                newIndex = rightIndex
+            }
+            
+            if newIndex == oldIndex {
+                break
+            }
+            
+            heap.swapAt(oldIndex, newIndex)
+            oldIndex = newIndex
+        }
+    }
+}
+
+struct Item: Comparable {
+    let num: Int
+    let count: Int
+
+    static func < (lhs: Item, rhs: Item) -> Bool {
+        return lhs.count <= rhs.count
+    }
+}
+
+class Solution {
+
+    /*
+        Runtime: 30 ms (Beats 65.79%)
+        Analyze Complexity: O(n log n), n개의 숫자에 대해 heappush, k개의 item에 대해 heappop
+        Memory: 17.63 MB (Beats 64.66%)
+    */
+    func topKFrequent(_ nums: [Int], _ k: Int) -> [Int] {
+        var countDict: [Int: Int] = [:]
+        for num in nums {
+            countDict[num] = (countDict[num] ?? 0) + 1
+        }
+
+        var maxHeap = MaxHeap<Item>()
+        for (num, count) in countDict {
+            maxHeap.insert(Item(num: num, count: count))
+        }
+
+        var result: [Int] = []
+        for _ in 0..<k {
+            if let maxItem = maxHeap.pop() {
+                result.append(maxItem.num)
+            }
+        }
+
+        return result
+    }
+}