7 problems

Author: partho-maple

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/1216_Valid_Palindrome_III.swift

@@ -0,0 +1,75 @@
+// Naive DFS with exhaustive search. TLE
+class Solution {
+    func isValidPalindrome(_ s: String, _ k: Int) -> Bool {
+        guard s.count > k else {
+            return true
+        }
+        return isValidPalindromeDFSHelper(Array(s), k)
+    }
+    
+    func isValidPalindromeDFSHelper(_ sArray: [Character], _ k: Int) -> Bool {
+        guard sArray.count > 1 else {
+            return true
+        }
+        
+        if isPalindrome(sArray) {
+            return true
+        } else if k > 0 {
+            var result = [Bool]()
+            for index in 0..<sArray.count {
+                var isPalin = false
+                if index == 0 {
+                    isPalin = isValidPalindromeDFSHelper(Array(sArray[(index + 1)..<sArray.count]), k - 1)
+                } else if index == sArray.count - 1 {
+                    isPalin = isValidPalindromeDFSHelper(Array(sArray[0..<index]), k - 1)
+                } else {
+                    isPalin = isValidPalindromeDFSHelper(Array(sArray[0..<index]) + Array(sArray[(index + 1)..<sArray.count]), k - 1)
+                }
+                result.append(isPalin)
+            }
+            return !result.allSatisfy { $0 == false }
+        } else {
+            return false
+        }
+    }
+    
+    func isPalindrome(_ sArray: [Character]) -> Bool {
+        var leftPtr = 0, rightPtr = sArray.count - 1
+        while leftPtr <= rightPtr {
+            if sArray[leftPtr] == sArray[rightPtr] {
+                leftPtr += 1
+                rightPtr -= 1
+            } else {
+                return false
+            }
+        }
+        return true
+    }
+}
+
+// 2D DP like Longest palindrome subsequence. Accepted
+class Solution {
+    func isValidPalindrome(_ s: String, _ k: Int) -> Bool {
+        guard s.count > k else {
+            return true
+        }
+        let sArray = Array(s)
+        var dp = Array(repeating: Array(repeating: 0, count: sArray.count), count: sArray.count)
+        
+        for i in 0..<sArray.count {
+            dp[i][i] = 1
+        }
+        
+        for startIndex in stride(from: sArray.count - 2, through: 0, by: -1) {
+            for endIndex in (startIndex + 1)..<sArray.count {
+                if sArray[startIndex] == sArray[endIndex] {
+                    dp[startIndex][endIndex] = 2 + dp[startIndex + 1][endIndex - 1]
+                } else {
+                    dp[startIndex][endIndex] = max(dp[startIndex + 1][endIndex], dp[startIndex][endIndex - 1])
+                }
+            }
+        }
+        
+        return (sArray.count - dp[0][sArray.count - 1]) <= k
+    }
+}

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/1382_Balance_a_Binary_Search_Tree.swift

@@ -0,0 +1,43 @@
+/**
+ * Definition for a binary tree node.
+ * 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 {
+    func balanceBST(_ root: TreeNode?) -> TreeNode? {
+        var sortedNodeVals = [Int]()
+        inorderDFS(root, &sortedNodeVals)
+        return balanceBST_HelperDFS(sortedNodeVals)
+    }
+    
+    func inorderDFS(_ root: TreeNode?, _ array: inout [Int] ) {
+        guard let root = root else {
+            return
+        }
+        inorderDFS(root.left, &array)
+        array.append(root.val)
+        inorderDFS(root.right, &array)
+    }
+    
+    func balanceBST_HelperDFS(_ sortedArray: [Int] ) -> TreeNode? {
+        guard sortedArray.count > 0 else {
+            return nil
+        }
+        let mid = sortedArray.count / 2
+        let root = TreeNode(sortedArray[mid])
+        root.left = balanceBST_HelperDFS(Array(sortedArray[0..<mid]))
+        root.right = balanceBST_HelperDFS(Array(sortedArray[(mid + 1)..<sortedArray.count]))
+        return root
+    }
+}

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/1570_Dot_Product_of_Two_Sparse_Vectors.swift

@@ -0,0 +1,51 @@
+// Using dictionary. Accepted
+class SparseVector {
+    var nonZeros = [Int:Int]()
+    init(_ nums: [Int]) {
+        for (index, item) in nums.enumerated() {
+            if item != 0 {
+                nonZeros[index] = item
+            }
+        }
+    }
+
+    // Return the dotProduct of two sparse vectors
+    func dotProduct(_ vec: SparseVector) -> Int {
+        var result = 0
+        for index in vec.nonZeros.keys {
+            if let otherItem = nonZeros[index] {
+                result += (otherItem * vec.nonZeros[index]!)
+            }
+        }
+        return result
+    }
+}
+
+// Using 2 pointers. Accepted
+class SparseVector {
+    var pairs = [(Int, Int)]() // (index, item)
+    init(_ nums: [Int]) {
+        for (index, item) in nums.enumerated() {
+            if item != 0 {
+                pairs.append((index, item))
+            }
+        }
+    }
+
+    // Return the dotProduct of two sparse vectors
+    func dotProduct(_ vec: SparseVector) -> Int {
+        var result = 0, ptrOne = 0, ptrTwo = 0
+        while ptrOne < pairs.count && ptrTwo < vec.pairs.count {
+            if pairs[ptrOne].0 == vec.pairs[ptrTwo].0 {
+                result += (pairs[ptrOne].1 * vec.pairs[ptrTwo].1)
+                ptrOne += 1
+                ptrTwo += 1
+            } else if pairs[ptrOne].0 < vec.pairs[ptrTwo].0 {
+                ptrOne += 1
+            } else {
+                ptrTwo += 1
+            }
+        }
+        return result
+    }
+}

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/1650_Lowest_Common_Ancestor_of_a_Binary_Tree_III.swift

@@ -0,0 +1,31 @@
+class Solution {
+    func lowestCommonAncestor(_ p: Node?,_ q: Node?) -> Node? {
+        var pDepth = getDepth(p, 0), qDepth = getDepth(q, 0)
+        var pCopy = p, qCopy = q
+        if pDepth > qDepth {
+            while pDepth > qDepth {
+                pCopy = pCopy.parent
+                pDepth -= 1
+            }
+        } else if pDepth < qDepth {
+            while pDepth < qDepth {
+                qCopy = qCopy.parent
+                qDepth -= 1
+            }
+        }
+        
+        while pCopy != qCopy {
+            pCopy = pCopy.parent
+            qCopy = qCopy.parent
+        }
+        
+        return pCopy
+    }
+    
+    func getDepth(_ node: Node?, _ depth: Int) -> Int {
+        guard let node = node else {
+            return depth
+        }
+        return getDepth(node.parent, depth + 1)
+    }
+}

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/1891_Cutting_Ribbons.swift

@@ -0,0 +1,25 @@
+class Solution {
+    func maxLength(_ ribbons: [Int], _ k: Int) -> Int {
+        var start = 1, end = ribbons.max()!, sum = ribbons.reduce(0, +)
+        if k > sum {
+            return 0
+        }
+        while start <= end {
+            let mid = start + ((end - start) / 2)
+            if iSPossibleToCut(ribbons, k, mid) {
+                start = mid + 1
+            } else {
+                end = mid - 1
+            }
+        }
+        return start - 1
+    }
+    
+    func iSPossibleToCut(_ ribbons: [Int], _ k: Int, _ targetLength: Int) -> Bool {
+        var count = 0
+        for ribbon in ribbons {
+            count += (ribbon / targetLength)
+        }
+        return count >= k ? true : false
+    }
+}

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/346_Moving_Average_from_Data_Stream.swift

@@ -0,0 +1,22 @@
+
+class MovingAverage {
+
+    var queue = [Int]()
+    var currentSum = 0
+    let size: Int
+    init(_ size: Int) {
+        self.size = size
+    }
+    
+    func next(_ val: Int) -> Double {
+        queue.append(val)
+        currentSum += val
+        if queue.count <= size {
+            return Double(currentSum) / Double(queue.count)
+        } else {
+            let first = queue.removeFirst()
+            currentSum -= first
+            return Double(currentSum) / Double(queue.count)
+        }
+    }
+}

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/827_Making_A_Large_Island.swift

@@ -0,0 +1,50 @@
+class Solution {
+    func largestIsland(_ grid: [[Int]]) -> Int {
+        var connectedGrid = grid
+        var parentID = 2, parentLengthMap = [Int:Int]()
+        for row in 0..<grid.count {
+            for col in 0..<grid[0].count {
+                if connectedGrid[row][col] == 1 {
+                    var currentLength = 1
+                    largestIslandDFSHelper(row, col, &connectedGrid, parentID, &currentLength)
+                    parentLengthMap[parentID] = currentLength
+                    parentID += 1
+                }
+            }
+        }
+        
+        var maxLength = Int.min
+        for row in 0..<grid.count {
+            for col in 0..<grid[0].count {
+                if connectedGrid[row][col] == 0 {
+                    var currentLength = 1, parentIdSet = Set<Int>()
+                    for (r, c) in [(0, -1), (-1, 0), (0, 1), (1, 0)] {
+                        let (newR, newC) = (row + r, col + c)
+                        if newR < 0 || newR >= connectedGrid.count || newC < 0 || newC >= connectedGrid[0].count || connectedGrid[newR][newC] == 0 {
+                            continue
+                        }
+                        let currentParentID = connectedGrid[newR][newC]
+                        if !parentIdSet.contains(currentParentID) {
+                            currentLength += parentLengthMap[currentParentID]!
+                            parentIdSet.insert(currentParentID)
+                        }
+                    }
+                    maxLength = max(maxLength, currentLength)
+                }
+            }
+        }
+        return maxLength == Int.min ? parentLengthMap.values.first! : maxLength
+    }
+    
+    func largestIslandDFSHelper(_ row: Int, _ col: Int, _ connectedGrid: inout [[Int]], _ parentID: Int, _ currentLength: inout Int) {
+        connectedGrid[row][col] = parentID
+        for (r, c) in [(0, -1), (-1, 0), (0, 1), (1, 0)] {
+            let (newR, newC) = (row + r, col + c)
+            if newR < 0 || newR >= connectedGrid.count || newC < 0 || newC >= connectedGrid[0].count || connectedGrid[newR][newC] != 1 {
+                continue
+            }
+            currentLength += 1
+            largestIslandDFSHelper(newR, newC, &connectedGrid, parentID, &currentLength)
+        }
+    }
+}