Added LRU and level order traversal

Author: Michael Ho

Data Structures/LRUCache.playground/Contents.swift

@@ -0,0 +1,81 @@
+// LRU Cache
+// Design and implement a data structure for Least Recently Used (LRU) cache.
+// It should support the following operations: get and put.
+
+import XCTest
+
+class LRU {
+    var capacity: Int
+    var count = 0
+    var head: Node?
+    var tail: Node?
+    var map = [Int:Node]()
+    
+    init(_ capacity: Int) {
+        self.capacity = capacity
+        tail = Node(-1, -1)
+        head = Node(-1, -1)
+        head?.next = tail
+        tail?.prev = head
+    }
+    
+    func get(_ key: Int) -> Int {
+        if let node = map[key] {
+            deleteNode(node)
+            moveToHead(node)
+            return node.val
+        } else {
+            return -1
+        }
+    }
+    
+    // Method to manipulate linked list
+    func moveToHead(_ node: Node?) {
+        node?.prev = head
+        head?.next = node
+        node?.next = head?.next
+        head?.next?.prev = node
+    }
+    
+    // Method to delete a node in linked list
+    func deleteNode(_ node: Node?) {
+        node?.prev?.next = node?.next
+        node?.next?.prev = node?.prev
+    }
+    
+    func put(_ key: Int, _ val: Int) {
+        if let node = map[key] {
+            node.key = key
+            node.val = val
+            deleteNode(node)
+            moveToHead(node)
+        } else {
+            if count == capacity, let last = tail?.prev {
+                deleteNode(last)
+                map[last.key] = nil
+                count -= 1
+            }
+            let new = Node(key, val)
+            map[key] = new
+            moveToHead(new)
+            count += 1
+        }
+    }
+}
+
+// Node for doubly linked list
+class Node {
+    var key: Int
+    var val: Int
+    var next: Node?
+    var prev: Node?
+    
+    init(_ key: Int, _ val: Int) {
+        self.key = key
+        self.val = val
+    }
+}
+
+class Tests: XCTestCase {
+    
+}

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

Data Structures/TreeTraversals.playground/Contents.swift

@@ -84,6 +84,34 @@ func inorderTraversal(_ root: TreeNode?) -> [Int] {
     return results
 }
 
+// level order traversal
+// Result should be: [1, 2, 3, 4, 5, 6, 7]
+func levelOrder(_ root: TreeNode?) -> [[Int]] {
+    var output = [[Int]]()
+    helper(0, root, &output)
+    return output
+}
+
+private func helper(_ level: Int, _ root: TreeNode?, _ output: inout [[Int]]) {
+    guard let root = root else {
+        return
+    }
+    
+    if output.count - 1 < level {
+        output.append([root.val])
+    } else {
+        output[level].append(root.val)
+    }
+    
+    if let left = root.left {
+        helper(level+1, left, &output)
+    }
+    
+    if let right = root.right {
+        helper(level+1, right, &output)
+    }
+}
+
 class Tests: XCTestCase {
     func testPreOrderTraversal() {
         let expected = [1, 2, 4, 5, 3, 6, 7]
@@ -99,6 +127,19 @@ class Tests: XCTestCase {
         let expected = [4, 2, 5, 1, 6, 3, 7]
         XCTAssertEqual(inorderTraversal(root), expected)
     }
+    
+    func testLevelOrderTraversal() {
+        let expected = [
+            [1],
+            [2, 3],
+            [4, 5, 6, 7]
+        ]
+        let output = levelOrder(root)
+        XCTAssertEqual(output.count, expected.count)
+        for i in 0..<output.count {
+            XCTAssertEqual(output[i], expected[i])
+        }
+    }
 }
 
 Tests.defaultTestSuite.run()

Medium/0043-MultiplyStrings.playground/Contents.swift

@@ -0,0 +1,28 @@
+// Leetcode: https://leetcode.com/problems/multiply-strings/
+
+import XCTest
+
+class Solution {
+    func multiply(_ num1: String, _ num2: String) -> String {
+        
+        return "String(output)"
+    }
+}
+
+class Tests: XCTestCase {
+    let s = Solution()
+    
+    func testSample1() {
+        let input = ("2", "3")
+        let expected = "6"
+        XCTAssertEqual(s.multiply(input.0, input.1), expected)
+    }
+    
+    func testSample2() {
+        let input = ("123", "456")
+        let expected = "56088"
+        XCTAssertEqual(s.multiply(input.0, input.1), expected)
+    }
+}
+
+Tests.defaultTestSuite.run()

Medium/0043-MultiplyStrings.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/0077-Combinations.playground/Contents.swift

@@ -1,63 +1,28 @@
 // LeetCode: https://leetcode.com/problems/combinations/description/
+// Current - Runtime: 184 ms, faster than 100.00% of Swift online submissions for Combinations.
 
 import XCTest
 
 class Solution {
     func combine(_ n: Int, _ k: Int) -> [[Int]] {
-        if n == 0 {
-            return []
-        }
-        var output: [[Int]] = []
-        var current: [Int] = []
-        if k < n/2 {
-            combine(n, k, current, &output)
-        } else {
-            for i in 1...n {
-                current.append(i)
-            }
-            guard n-k > 0 else {
-                return [current]
-            }
-            remove(n-k, 0, current, &output)
+        var output = [[Int]]()
+        guard n > 0, k > 0, n >= k else {
+            return output
         }
 
-        return output
-    }
-    
-    private func combine(_ n: Int, _ k: Int, _ current: [Int], _ output: inout [[Int]]) {
-        if current.count == k {
-            if !output.contains(current) {
-                output.append(current)
-            }
-            return
-        }
-        let last = current.last ?? 1
-        for i in last...n {
-            if current.contains(i) {
-                continue
+        var i = n
+        while i > 0 {
+            if k == 1 {
+                output.append([i])
+            } else {
+                for o in combine(i-1, k-1) {
+                    output.append([i] + o)
+                }
             }
-            var temp = current
-            temp.append(i)
-            combine(n, k, temp, &output)
-        }
-    }
-    
-    private func remove(_ toRemove: Int, _ cursor: Int, _ current: [Int], _ output: inout [[Int]]) {
-        if toRemove == 0 {
-            if !output.contains(current) {
-                output.append(current)
-            }
-            return
-        }
-        var idx = 0
-        for (idx, i) in current.enumerated() {
-            if i <= cursor {
-                continue
-            }
-            var temp = current
-            temp.remove(at: idx)
-            remove(toRemove-1, i, temp, &output)
+            
+            i -= 1
         }
+        return output
     }
 }
 
@@ -80,23 +45,6 @@ class Tests: XCTestCase {
             XCTAssertTrue(expected.contains(o))
         }
     }
-    
-    func testSample2() {
-        let input = (20, 16)
-        let expected = [
-            [2,4],
-            [3,4],
-            [2,3],
-            [1,2],
-            [1,3],
-            [1,4],
-            ]
-        let output = s.combine(input.0, input.1)
-        XCTAssertEqual(output.count, expected.count)
-        for o in output {
-            XCTAssertTrue(expected.contains(o))
-        }
-    }
 }
 
 Tests.defaultTestSuite.run()