First update in 2019

Author: Michael Ho

Data Structures/Heap.playground/Contents.swift

@@ -0,0 +1,128 @@
+// Heap
+// Maxheaps: Elements with a higher value represent higher priority.
+// Minheaps: Elements with a lower value represent higher priority.
+
+import Foundation
+
+struct Heap<Element> {
+    var elements : [Element]
+    let priorityFunction : (Element, Element) -> Bool
+    
+    init(elements: [Element] = [], priorityFunction: @escaping (Element, Element) -> Bool) {
+        self.elements = elements
+        self.priorityFunction = priorityFunction
+        buildHeap()
+    }
+    
+    mutating func buildHeap() {
+        for index  in (0 ..< count/2).reversed() {
+            siftDown(elementAtIndex: index)
+        }
+    }
+    
+    var isEmpty : Bool { return elements.isEmpty }
+    var count : Int { return elements.count }
+    
+    func peek() -> Element? {
+        return elements.first
+    }
+    
+    mutating func enqueue(_ element: Element) {
+        elements.append(element)
+        siftUp(elementAtIndex: count - 1)
+    }
+    
+    mutating func siftUp(elementAtIndex index: Int) {
+        let parent = parentIndex(of: index)
+        guard !isRoot(index),
+            isHigherPriority(at: index, than: parent)
+            else { return }
+        swapElement(at: index, with: parent)
+        siftUp(elementAtIndex: parent)
+    }
+    
+    mutating func dequeue() -> Element? {
+        guard !isEmpty
+            else { return nil }
+        swapElement(at: 0, with: count - 1)
+        let element = elements.removeLast()
+        if !isEmpty {
+            siftDown(elementAtIndex: 0)
+        }
+        return element
+    }
+    
+    mutating func siftDown(elementAtIndex index: Int) {
+        let childIndex = highestPriorityIndex(for: index)
+        if index == childIndex {
+            return
+        }
+        swapElement(at: index, with: childIndex)
+        siftDown(elementAtIndex: childIndex)
+    }
+    
+    // Helper functions
+    func isRoot(_ index: Int) -> Bool {
+        return index == 0
+    }
+    
+    func leftChildIndex(of index: Int) -> Int {
+        return (2 * index) + 1
+    }
+    
+    func rightChildIndex(of index: Int) -> Int {
+        return (2 * index) + 2
+    }
+    
+    func parentIndex(of index: Int) -> Int {
+        return (index - 1) / 2
+    }
+    
+    func isHigherPriority(at firstIndex: Int, than secondIndex: Int) -> Bool {
+        return priorityFunction(elements[firstIndex], elements[secondIndex])
+    }
+    
+    func highestPriorityIndex(of parentIndex: Int, and childIndex: Int) -> Int {
+        guard childIndex < count && isHigherPriority(at: childIndex, than: parentIndex)
+            else { return parentIndex }
+        return childIndex
+    }
+    
+    func highestPriorityIndex(for parent: Int) -> Int {
+        return highestPriorityIndex(of: highestPriorityIndex(of: parent, and: leftChildIndex(of: parent)), and: rightChildIndex(of: parent))
+    }
+    
+    mutating func swapElement(at firstIndex: Int, with secondIndex: Int) {
+        guard firstIndex != secondIndex
+            else { return }
+        swap(&elements[firstIndex], &elements[secondIndex])
+    }
+}
+
+// A bonus extra for you: two extra functions, if the Element type is Equatable
+extension Heap where Element : Equatable {
+    
+    // This function allows you to remove an element from the heap, in a similar way to how you would dequeue the root element.
+    mutating func remove(_ element: Element) {
+        guard let index = elements.index(of: element)
+            else { return }
+        swapElement(at: index, with: count - 1)
+        elements.remove(at: count - 1)
+        siftDown(elementAtIndex: index)
+    }
+    
+    // This function allows you to 'boost' an element, by sifting the element up the heap. You might do this if the element is already in the heap, but its priority has increased since it was enqueued.
+    mutating func boost(_ element: Element) {
+        guard let index = elements.index(of: element)
+            else { return }
+        siftUp(elementAtIndex: index)
+    }
+}
+
+var heap = Heap<Int>(elements: [3, 2, 8, 5, 0], priorityFunction: >)
+heap.enqueue(6)
+heap.enqueue(1)
+heap.enqueue(4)
+heap.enqueue(7)
+heap.dequeue()
+print(heap.elements)

Data Structures/ImplementTrie-PrefixTree.playground/Contents.swift

@@ -0,0 +1,80 @@
+/**
+ Trie implementation
+ 
+ LeetCode: https://leetcode.com/problems/implement-trie-prefix-tree
+ */
+
+class Trie {
+    var root: Node
+    
+    // Initialize your data structure here.
+    init() {
+        self.root = Node()
+    }
+    
+    // Inserts a word into the trie.
+    func insert(_ word: String) {
+        var currentNode = self.root
+        for ch in word {
+            if currentNode.children[ch] == nil {
+                currentNode.children[ch] = Node(ch)
+            }
+            currentNode = currentNode.children[ch]!
+        }
+        // Only go through to the last node represents a word
+        currentNode.isWord = true
+    }
+    
+    // Returns if the word is in the trie.
+    func search(_ word: String) -> Bool {
+        var currentNode = self.root
+        for ch in word {
+            if currentNode.children[ch] != nil {
+                currentNode = currentNode.children[ch]!
+            } else {
+                return false
+            }
+        }
+        return currentNode.isWord
+    }
+    
+    // Returns if there is any word in the trie that starts with the given prefix.
+    func startsWith(_ prefix: String) -> Bool {
+        var currentNode = self.root
+        for ch in prefix {
+            if currentNode.children[ch] != nil {
+                currentNode = currentNode.children[ch]!
+            } else {
+                return false
+            }
+        }
+        return true
+    }
+}
+
+public class Node {
+    var val: Character
+    var children: [Character : Node]
+    var isWord: Bool
+    
+    init() {
+        self.val = "*"
+        self.children = [:]
+        self.isWord = false
+    }
+    
+    init(_ val: Character) {
+        self.val = val
+        self.children = [:]
+        self.isWord = false
+    }
+}
+
+// Test cases
+let trie = Trie()
+trie.insert("apple")
+trie.search("apple")   // returns true
+trie.search("app")     // returns false
+trie.startsWith("app") // returns true
+trie.insert("app")
+trie.search("app")

Data Structures/ImplementTrie-PrefixTree.playground/contents.xcplayground

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<playground version='5.0' target-platform='macos' executeOnSourceChanges='false'>
+    <timeline fileName='timeline.xctimeline'/>
+</playground>

Easy/0021-MergeTwoSortedLists.playground/Contents.swift

@@ -1,5 +1,7 @@
 // LeetCode: https://leetcode.com/problems/merge-two-sorted-lists/description/
 
+import XCTest
+
 public class ListNode {
     public var val: Int
     public var next: ListNode?
@@ -8,48 +10,49 @@ public class ListNode {
         self.next = nil
     }
 }
+
 class Solution {
     func mergeTwoLists(_ l1: ListNode?, _ l2: ListNode?) -> ListNode? {
-        if nil != l1, nil == l2 {
-            return l1
-        } else if nil == l1, nil != l2 {
+        guard l1 != nil || l2 != nil else {
+            return nil
+        }
+        if l1 == nil {
             return l2
+        } else if l2 == nil {
+            return l1
         }
 
-        guard let l1 = l1, let l2 = l2 else {
-            return nil
-        }
-        var head: ListNode?
-        var output: ListNode?
-        var list1: ListNode? = l1
-        var list2: ListNode? = l2
-        if (list1?.val)! < (list2?.val)! {
-            head = l1
-            list1 = list1?.next
+        var l1 = l1
+        var l2 = l2
+        var value: Int!
+        if (l1?.val)! < (l2?.val)! {
+            value = (l1?.val)!
+            l1 = l1?.next
         } else {
-            head = l2
-            list2 = list2?.next
+            value = (l2?.val)!
+            l2 = l2?.next
         }
-        output = head
+        var head = ListNode(value)
+        var node: ListNode? = head
 
-        while nil != list1 || nil != list2 {
-            guard nil != list1 else {
-                head?.next = list2
-                return output
-            }
-            guard nil != list2 else {
-                head?.next = list1
-                return output
+        while l1 != nil || l2 != nil {
+            if l1 == nil {
+                node?.next = l2
+                break
+            } else if l2 == nil {
+                node?.next = l1
+                break
             }
-            if (list1?.val)! < (list2?.val)! {
-                head?.next = list1
-                list1 = list1?.next
+            
+            if (l1?.val)! < (l2?.val)! {
+                node?.next = ListNode((l1?.val)!)
+                l1 = l1?.next
             } else {
-                head?.next = list2
-                list2 = list2?.next
+                node?.next = ListNode((l2?.val)!)
+                l2 = l2?.next
             }
-            head = head?.next
+            node = node?.next
         }
-        return output
+        return head
     }
 }

Easy/0219-ContainsDuplicateII.playground/Contents.swift

@@ -0,0 +1,32 @@
+// LeetCode: https://leetcode.com/problems/contains-duplicate-ii/description/
+
+import XCTest
+
+class Solution {
+    func containsNearbyDuplicate(_ nums: [Int], _ k: Int) -> Bool {
+        var dict: [Int:Int] = [:]
+        for (idx, num) in nums.enumerated() {
+            if dict[num] != nil, idx - dict[num]! <= k {
+                return true
+            }
+            dict[num] = idx
+        }
+        return false
+    }
+}
+
+class Tests: XCTestCase {
+    let s = Solution()
+    
+    func testSample1() {
+        let input = ([1,2,3,1,2,3], 2)
+        XCTAssertFalse(s.containsNearbyDuplicate(input.0, input.1))
+    }
+    
+    func testSample2() {
+        let input = ([1,0,1,1], 1)
+        XCTAssertTrue(s.containsNearbyDuplicate(input.0, input.1))
+    }
+}
+
+Tests.defaultTestSuite.run()

Easy/0219-ContainsDuplicateII.playground/contents.xcplayground

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<playground version='5.0' target-platform='macos' executeOnSourceChanges='false'>
+    <timeline fileName='timeline.xctimeline'/>
+</playground>