Merge branch 'master' of github.com:partho-maple/coding-interview-gym

* 'master' of github.com:partho-maple/coding-interview-gym:
  no message
  no message
  no message
  no message
  no message
  cleanup
  408_Valid_Word_Abbreviation

Author: partho-maple

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/129_Sum_Root_to_Leaf_Numbers.swift

@@ -54,3 +54,32 @@ class Solution {
         return node.left == nil && node.right == nil
     }
 }
+
+
+// Second try
+class Solution {
+    func sumNumbers(_ root: TreeNode?) -> Int {
+        var currentPath = [Int](), currentSum = 0
+        sumNumbersDFSHelper(root, currentPath, &currentSum)
+        return currentSum
+    }
+
+    func sumNumbersDFSHelper(_ root: TreeNode?, _ currentPath: [Int], _ currentSum: inout Int) {
+        guard let root = root else {
+            return
+        }
+
+        if root.left == nil && root.right == nil {
+            let currentPath = currentPath + [root.val]
+            let currentNumStr = currentPath.reduce("") { $0 + String($1) }
+            let currentNum = Int(currentNumStr)
+            currentSum += currentNum!
+        }
+        if let left = root.left {
+            sumNumbersDFSHelper(left, currentPath + [root.val], &currentSum)
+        }
+        if let right = root.right {
+            sumNumbersDFSHelper(right, currentPath + [root.val], &currentSum)
+        }
+    }
+}

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/133_Clone_Graph.swift

@@ -15,27 +15,23 @@ import Foundation
 
 class Solution {
     func cloneGraph(_ node: Node?) -> Node? {
-        guard let unWrappedNode = node else { return node}
-        
-        var nodeDict = [Int: Node]()
-        let clonedNode = self.cloneGraphHelper(unWrappedNode, &nodeDict)
-        return clonedNode
+        guard let node = node else { return node}
+        var visited = [Int: Node]()
+        return cloneGraphHelper(node, &visited)
     }
 
-    func cloneGraphHelper(_ node: Node, _ nodeDict: inout [Int: Node]) -> Node {
-        if let existingNode = nodeDict[node.val] {
+    func cloneGraphHelper(_ node: Node, _ visited: inout [Int: Node]) -> Node {
+        if let existingNode = visited[node.val] {
             return existingNode
         }
 
-        var clonedNode = Node(node.val)
-        nodeDict[node.val] = clonedNode
-        node.neighbors.forEach {neighbor in
+        visited[node.val] = Node(node.val)
+        node.neighbors.forEach { neighbor in
             if let unWrappedNeighbor = neighbor {
-                let clonedNeighbour = self.cloneGraphHelper(unWrappedNeighbor, &nodeDict)
-                nodeDict[node.val]?.neighbors.append(clonedNeighbour)
+                visited[node.val]?.neighbors.append(self.cloneGraphHelper(unWrappedNeighbor, &visited))
             }
         }
-        return clonedNode
+        return visited[node.val]!
     }
 }
 

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/199_Binary_Tree_Right_Side_View.swift

@@ -14,6 +14,8 @@ import Foundation
  *     }
  * }
  */
+
+// DFS
 class Solution {
     func rightSideView(_ root: TreeNode?) -> [Int] {
         guard var root = root else {
@@ -37,3 +39,31 @@ class Solution {
         rightSideViewDFSHelper(root.left, currentDepth + 1, &maxDepthSoFar, &rightView)
     }
 }
+
+
+// BFS with level size measurement
+class Solution {
+    func rightSideView(_ root: TreeNode?) -> [Int] {
+        guard let root = root else {
+            return []
+        }
+        var result = [Int](), queue = [TreeNode](), currentLevelLength = 1
+        queue.append(root)
+        while !queue.isEmpty {
+            var rightMostNode = Int.min, currentLevelLength = queue.count
+            while currentLevelLength > 0 {
+                let node = queue.removeFirst()
+                rightMostNode = node.val
+                currentLevelLength -= 1
+                if let left = node.left {
+                    queue.append(left)
+                }
+                if let right = node.right {
+                    queue.append(right)
+                }
+            }
+            result.append(rightMostNode)
+        }
+        return result
+    }
+}

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/253_Meeting_Rooms_II.swift

@@ -46,3 +46,23 @@ class Solution {
         return occupiedRooms.count
     }
 }
+
+
+
+// Improved Code
+class Solution {
+    func minMeetingRooms(_ intervals: [[Int]]) -> Int {
+        guard intervals.count > 1 else {
+            return 1
+        }
+        let sortedInterval = intervals.sorted { $0[0] < $1[0] }
+        var minHeap: Heap<Int> = Heap<Int>(sort: <)
+        for i in 0..<sortedInterval.count {
+            if let peak = minHeap.peek(), peak <= sortedInterval[i][0] {
+                minHeap.remove()
+            }
+            minHeap.insert(sortedInterval[i][1])
+        }
+        return minHeap.count
+    }
+}

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/31_Next_Permutation.swift

@@ -1,15 +1,14 @@
-
 import Foundation
 
+// My first attempt
 class Solution {
     func nextPermutation(_ nums: inout [Int]) {
         guard nums.count >= 2 else {
             return
         }
 
         for leftIdx in stride(from:(nums.count - 2), through:0, by:-1) {
-            var leftNum = nums[leftIdx]
-            var rightNum = nums[leftIdx + 1]
+            let leftNum = nums[leftIdx], rightNum = nums[leftIdx + 1]
             if leftNum < rightNum {
                 var swapIdx = leftIdx + 1
                 for i in (swapIdx..<nums.count) {
@@ -25,3 +24,29 @@ class Solution {
         nums.reverse()
     }
 }
+
+
+// My second attempt
+class Solution {
+    func nextPermutation(_ nums: inout [Int]) {
+        guard nums.count > 1 else {
+            return
+        }
+        for rightIdx in stride(from: nums.count - 1, through: 1, by: -1) {
+            let rightNum = nums[rightIdx], leftNum = nums[rightIdx - 1]
+            if rightNum > leftNum {
+                var swapIdx = rightIdx, nextGraterNum = rightNum
+                for j in swapIdx..<nums.count {
+                    if leftNum < nums[j] && nums[j] < nextGraterNum  {
+                        swapIdx = j
+                        nextGraterNum = nums[j]
+                    }
+                }
+                nums.swapAt(rightIdx - 1, swapIdx)
+                nums[rightIdx..<nums.count].sort()
+                return
+            }
+        }
+        nums.sort()
+    }
+}

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/339_Nested_List_Weight_Sum.swift

@@ -22,6 +22,8 @@ import Foundation
  *     public func getList() -> [NestedInteger]
  * }
  */
+
+// Old solution
 class Solution {
     func depthSum(_ nestedList: [NestedInteger]) -> Int {
         var wrightSum = 0
@@ -42,10 +44,23 @@ class Solution {
     }
 }
 
-/*
-[[1,1],2,[1,1]]
 
-1*2 + 1*2 + 1*2 +1*2 + 2*1
 
-[[1,1],2,[1,1]]
-*/
+// New solution
+class Solution {
+    func depthSum(_ nestedList: [NestedInteger]) -> Int {
+        return depthSumDFSHelper(nestedList, 1)
+    }
+
+    func depthSumDFSHelper(_ nestedList: [NestedInteger], _ currentDepth: Int) -> Int {
+        var currentSum = 0
+        for nInt in nestedList {
+            if nInt.isInteger() {
+                currentSum += (nInt.getInteger() * currentDepth)
+            } else {
+                currentSum += (depthSumDFSHelper(nInt.getList(), currentDepth + 1))
+            }
+        }
+        return currentSum
+    }
+}

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/408_Valid_Word_Abbreviation.swift

@@ -0,0 +1,35 @@
+import Foundation
+
+class Solution {
+    func validWordAbbreviation(_ word: String, _ abbr: String) -> Bool {
+        let wordArray = Array(word), abbrArray = Array(abbr)
+        var wordPtr = 0, abbrPtr = 0, currentNumber = [String]()
+        while wordPtr < wordArray.count && abbrPtr < abbrArray.count {
+            if abbrArray[abbrPtr].isNumber {
+                if currentNumber.isEmpty && String(abbrArray[abbrPtr]) == "0" {
+                    return false
+                }
+                currentNumber.append(String(abbrArray[abbrPtr]))
+                abbrPtr += 1
+            } else if currentNumber.count > 0 {
+                let num = Int(currentNumber.reduce("") { $0 + $1 })
+                wordPtr += num!
+                currentNumber.removeAll()
+            } else if wordArray[wordPtr] == abbrArray[abbrPtr] {
+                wordPtr += 1
+                abbrPtr += 1
+            } else {
+                return false
+            }
+        }
+
+        if currentNumber.count > 0 {
+            let num = Int(currentNumber.reduce("") { $0 + $1 })
+            wordPtr += num!
+            currentNumber.removeAll()
+        }
+        return (wordPtr == wordArray.count && abbrPtr == abbrArray.count) ? true : false
+    }
+}
+
+

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/50_Pow(x, n).swift

@@ -0,0 +1,19 @@
+import Foundation
+
+// Video: https://www.youtube.com/watch?v=g9YQyYi4IQQ
+class Solution {
+    func myPow(_ x: Double, _ n: Int) -> Double {
+        if n == 0 {
+            return 1
+        }
+        if n < 0 {
+            return 1 / myPow(x, -n)
+        }
+        let half = myPow(x, n/2)
+        if n % 2 == 0 {
+            return half * half
+        } else {
+            return x * half * half
+        }
+    }
+}

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/742_Closest_Leaf_in_a_Binary_Tree.swift

@@ -0,0 +1,40 @@
+import Foundation
+
+class Solution {
+    func findClosestLeaf(_ root: TreeNode?, _ k: Int) -> Int {
+        var graph = [Int:[Int]](), queue = [(TreeNode?, TreeNode)]() // (currentNode, parentNode)
+        queue.append((root, TreeNode(Int.max)))
+
+        // Creates the graph.
+        while !queue.isEmpty {
+            let (node, parentNode) = queue.removeFirst()
+            if let node = node {
+                graph[node.val, default: [Int]()].append(parentNode.val)
+                graph[parentNode.val, default: [Int]()].append(node.val)
+                queue.append((node.left, node))
+                queue.append((node.right, node))
+            }
+        }
+
+        var valQueue = [Int](), visited = Set<Int>()
+        valQueue.append(k)
+        while !valQueue.isEmpty {
+            let currentNodeVal = valQueue.removeFirst()
+            visited.insert(currentNodeVal)
+            if let neighbours = graph[currentNodeVal] {
+                if neighbours.count <= 1 && currentNodeVal != Int.max {
+                    return currentNodeVal
+                }
+                for i in 0..<neighbours.count {
+                    let neighbour = neighbours[i]
+                    if !visited.contains(neighbour) {
+                        valQueue.append(neighbour)
+                    }
+                }
+            } else {
+                return currentNodeVal
+            }
+        }
+        return -1
+    }
+}