Added new solutions

Author: Michael Ho

Data Structures/Heap.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>

Hard/0023-MergeKSortedLists.playground/Contents.swift

@@ -1,5 +1,7 @@
 // LeetCode: https://leetcode.com/problems/merge-k-sorted-lists/description/
 
+import XCTest
+
 public class ListNode {
     public var val: Int
     public var next: ListNode?
@@ -11,33 +13,65 @@ public class ListNode {
 
 class Solution {
     func mergeKLists(_ lists: [ListNode?]) -> ListNode? {
-        var arr: [Int] = []
+        var arr = [Int]()
+        
         for head in lists {
-            arr = arr + toArray(head)
+            var node = head
+            while node != nil {
+                arr.append((node?.val)!)
+                node = node?.next
+            }
         }
         arr = arr.sorted()
-        return toLinkedList(arr: arr)
+        return toLinkedList(arr)
     }
-    private func toArray(_ head: ListNode?) -> [Int] {
-        guard nil != head else {
-            return []
-        }
-        var arr: [Int] = []
-        var node = head
-        while nil != node {
-            arr.append((node?.val)!)
+    
+    private func toLinkedList(_ arr: [Int]) -> ListNode? {
+        guard arr.count > 0 else {
+            return nil
+        }
+        guard arr.count > 1 else {
+            return ListNode(arr[0])
+        }
+        let head = ListNode(arr[0])
+        var node: ListNode? = ListNode(arr[1])
+        head.next = node
+        var index = 1
+        while index + 1 < arr.count {
+            node?.next = ListNode(arr[index+1])
             node = node?.next
+            index += 1
         }
-        return arr
+        return head
     }
-    private func toLinkedList(arr: [Int]) -> ListNode? {
+}
+
+class Tests: XCTestCase {
+    let s = Solution()
+    
+    func testSample1() {
+        let input: [ListNode?] = [
+            arrayToLinkedList([1,4,5]),
+            arrayToLinkedList([1,3,4]),
+            arrayToLinkedList([2,6])
+        ]
+        var output = s.mergeKLists(input)
+        var expected = arrayToLinkedList([1,1,2,3,4,4,5,6])
+        while expected != nil {
+            XCTAssertEqual(expected?.val, output?.val)
+            output = expected?.next
+            expected = expected?.next
+        }
+    }
+    
+    private func arrayToLinkedList(_ arr: [Int]) -> ListNode? {
         guard arr.count > 0 else {
             return nil
         }
         guard arr.count > 1 else {
             return ListNode(arr[0])
         }
-        var head = ListNode(arr[0])
+        let head = ListNode(arr[0])
         var node: ListNode? = ListNode(arr[1])
         head.next = node
         var index = 1
@@ -49,3 +83,5 @@ class Solution {
         return head
     }
 }
+
+Tests.defaultTestSuite.run()

Hard/0146-LRUCache.playground/Contents.swift

@@ -0,0 +1,109 @@
+// LeetCode: https://leetcode.com/problems/lru-cache/
+
+import XCTest
+
+// Use doubly linked list.
+class Node {
+    var val: Int
+    var key: Int
+    var pre: Node?
+    var next: Node?
+    
+    init(_ key: Int, _ val: Int) {
+        self.key = key
+        self.val = val
+    }
+}
+
+class LRU {
+    var capacity: Int
+    var dataCount: Int
+    var map = [Int:Node]()
+    var head: Node?
+    var tail: Node?
+    
+    init(_ capacity: Int) {
+        self.capacity = capacity
+        head = Node(-1, -1)
+        tail = Node(-1, -1)
+        head?.next = tail
+        tail?.pre = head
+        dataCount = 0
+    }
+    
+    func get(_ key: Int) -> Int {
+        if let node = map[key] {
+            deleteNode(node)
+            moveToHead(node)
+            return node.val
+        } else {
+            return -1
+        }
+    }
+    
+    private func deleteNode(_ node: Node?) {
+        node?.pre?.next = node?.next
+        node?.next?.pre = node?.pre
+    }
+    
+    private func moveToHead(_ node: Node?) {
+        node?.next = head?.next
+        head?.next?.pre = node
+        head?.next = node
+        node?.pre = head
+    }
+    
+    func put(_ key: Int, _ val: Int) {
+        if let existNode = map[key] {
+            existNode.key = key
+            existNode.val = val
+            deleteNode(existNode)
+            moveToHead(existNode)
+        } else {
+            if dataCount == capacity {
+                if let last = tail?.pre {
+                    map[last.key] = nil
+                    deleteNode(last)
+                }
+                dataCount -= 1
+            }
+            
+            let node = Node(key, val)
+            map[key] = node
+            moveToHead(node)
+            dataCount += 1
+        }
+    }
+}
+
+class Tests: XCTestCase {
+    
+    func test1() {
+        let cache = LRU(2)
+        
+        cache.put(1, 1)
+        cache.put(2, 2)
+        XCTAssertEqual(cache.get(1), 1)
+        
+        cache.put(3, 3)
+        XCTAssertEqual(cache.get(2), -1) // (not found)
+        
+        cache.put(4, 4)
+        XCTAssertEqual(cache.get(1), -1) // (not found)
+        XCTAssertEqual(cache.get(3), 3)
+        XCTAssertEqual(cache.get(4), 4)
+    }
+    
+    func test2() {
+        let cache = LRU(2)
+        
+        cache.put(2, 1)
+        cache.put(1, 1)
+        cache.put(2, 3)
+        cache.put(4, 1)
+        XCTAssertEqual(cache.get(1), -1)
+        XCTAssertEqual(cache.get(2), 3)
+    }
+}
+
+Tests.defaultTestSuite.run()

Hard/0146-LRUCache.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>

Medium/0005-LongestPalindromicSubstring.playground/Contents.swift

@@ -0,0 +1,71 @@
+// LeetCode: https://leetcode.com/problems/longest-palindromic-substring/
+// Hint: moving frame
+
+import XCTest
+
+class Solution {
+    func longestPalindrome(_ s: String) -> String {
+        guard s.count > 0 else { return "" }
+    
+        var length = s.count
+        var strArr = Array(s)
+        
+        while length > 0 {
+            for i in 0...s.count-length {
+                var left = i
+                var right = i+length-1
+                
+                if right >= strArr.count {
+                    break
+                }
+                
+                var isPalindrome = true
+                while left < right {
+                    if strArr[left] != strArr[right] {
+                        isPalindrome = false
+                        break
+                    }
+                    
+                    left += 1
+                    right -= 1
+                }
+
+                if isPalindrome {
+                    return String(strArr[i..<i+length])
+                }
+            }
+            length -= 1
+        }
+        return String(strArr[0])
+    }
+}
+
+class Tests: XCTestCase {
+    let s = Solution()
+    
+    func testSample1() {
+        let input = "babad"
+        let expected = "bab"
+        XCTAssertEqual(s.longestPalindrome(input), expected)
+    }
+
+    func testSample2() {
+        let input = "cbbd"
+        let expected = "bb"
+        XCTAssertEqual(s.longestPalindrome(input), expected)
+    }
+
+    func testSample3() {
+        let input = "ac"
+        let expected = "a"
+        XCTAssertEqual(s.longestPalindrome(input), expected)
+    }
+    
+    func testSample4() {
+        let input = "abcda"
+        let expected = "a"
+        XCTAssertEqual(s.longestPalindrome(input), expected)
+    }
+}
+
+Tests.defaultTestSuite.run()

Medium/0005-LongestPalindromicSubstring.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>

Udacity Practices/SortingAlgorithms.playground/Contents.swift

@@ -76,13 +76,14 @@ print("\(mergeSort(testArray))")
      - Average: O(nlog(n))
      - Worst:   O(n^2)
  Space:
-     - O(1)
+     - Average: O(log(n))
+     - Worst:   O(n)
  */
 
 func quicksort(_ nums: [Int])  -> [Int] {
     guard nums.count > 1 else { return nums }
 
-    let pivot = nums[nums.count/2]
+    let pivot = nums[nums.count-1]
     let less = nums.filter { $0 < pivot }
     let equal = nums.filter { $0 == pivot }
     let greater = nums.filter { $0 > pivot }