multiple problems

Author: partho-maple

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/1166_Design_File_System.swift

@@ -0,0 +1,80 @@
+
+class FileSystem {
+
+    var trie = Trie()
+    init() {
+        
+    }
+    
+    func createPath(_ path: String, _ value: Int) -> Bool {
+        return trie.insert(path, value)
+    }
+    
+    func get(_ path: String) -> Int {
+        return trie.contains(path)
+    }
+}
+
+class TrieNode {
+    var name: String
+    var children: [String:TrieNode]
+    var value: Int
+    
+    init(_ name: String, _ value: Int = -1, children: [String:TrieNode] = [:]) {
+        self.name = name
+        self.children = children
+        self.value = value
+    }
+}
+
+class Trie {
+    var root: TrieNode
+    
+    init () {
+        root = TrieNode("/")
+    }
+    
+    func insert(_ path: String, _ value: Int) -> Bool {
+        let pathComponents = path.split(separator: "/").map { String($0) }
+        guard pathComponents.count > 0 else {
+            return false
+        }
+        
+        var currentNode = root
+        for (_, item) in pathComponents.enumerated() {
+            if currentNode.children[item] == nil {
+                if item == pathComponents.last {
+                    let newNode = TrieNode(item)
+                    currentNode.children[item] = newNode
+                } else {
+                    return false
+                }
+            }
+            currentNode = currentNode.children[item]!
+        }
+        
+        if currentNode.value != -1 {
+            return false
+        } else {
+            currentNode.value = value
+            return true
+        }
+    }
+    
+    func contains(_ path: String) -> Int {
+        let pathComponents = path.split(separator: "/").map { String($0) }
+        guard pathComponents.count > 0 else {
+            return -1
+        }
+        
+        var currentNode = root
+        for (_, item) in pathComponents.enumerated() {
+            if let nextNode = currentNode.children[item] {
+                currentNode = nextNode
+            } else {
+                return -1
+            }
+        }
+        return currentNode.value
+    }
+}

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/1293_Shortest_Path_in_a_Grid_with_Obstacles_Elimination.swift

@@ -0,0 +1,82 @@
+// Simple DFS without memoization. TLE
+class Solution {
+    func shortestPath(_ grid: [[Int]], _ k: Int) -> Int {
+        let m = grid.count, n = grid[0].count
+        var minSteps = Int.max, visitedGrid = Array(repeating: Array(repeating: -1, count: n), count: m)
+        shortestPathDFSHelper(grid, k, k, 0, 0, 0, &minSteps, &visitedGrid)
+        return minSteps == Int.max ? -1 : minSteps
+    }
+
+    func shortestPathDFSHelper(
+        _ grid: [[Int]],
+        _ k: Int,
+        _ remainingK: Int,
+        _ startRowIdx: Int,
+        _ startColIdx: Int,
+        _ currentSteps: Int,
+        _ minSteps: inout Int,
+        _ visitedGrid: inout [[Int]]
+    ) {
+        let m = grid.count, n = grid[0].count
+        if remainingK < 0 {
+            return
+        }
+        if startRowIdx == m - 1 && startColIdx == n - 1 {
+            minSteps = min(minSteps, currentSteps)
+            return
+        }
+
+        for (r, c) in [(0, -1), (-1, 0), (0, 1), (1, 0)] {
+            let newR = startRowIdx + r, newC = startColIdx + c
+            if newR < 0 || newR >= m || newC < 0 || newC >= n || visitedGrid[newR][newC] != -1 {
+                continue
+            }
+            let cellVal = grid[newR][newC]
+            visitedGrid[newR][newC] = 0 // marking this cell as visited
+            if cellVal == 0 {
+                shortestPathDFSHelper(grid, k, remainingK, newR, newC, currentSteps + 1, &minSteps, &visitedGrid)
+            } else {
+                shortestPathDFSHelper(grid, k, remainingK - 1, newR, newC, currentSteps + 1, &minSteps, &visitedGrid)
+            }
+            visitedGrid[newR][newC] = -1 // backtracking
+        }
+    }
+}
+
+
+// BFS with memoization. Accepted
+class Solution {
+    func shortestPath(_ grid: [[Int]], _ k: Int) -> Int {
+        let m = grid.count, n = grid[0].count
+        var minSteps = Int.max, visitedGrid = Array(repeating: Array(repeating: Array(repeating: -1,
+                                                                                      count: k + 1),
+                                                                     count: n),
+                                                    count: m)
+        var queue = [(Int, Int, Int, Int)]() // (row, col, currentSteps, remainingRemoval)
+        queue.append((0, 0, 0, k))
+        while !queue.isEmpty {
+            let (row, col, currentSteps, remainingRemoval) = queue.removeFirst()
+            visitedGrid[row][col][remainingRemoval] = 0 // marking it as visited
+            if row == m - 1 && col == n - 1 && remainingRemoval >= 0 {
+                minSteps = min(minSteps, currentSteps)
+            }
+            
+            for (r, c) in [(0, -1), (-1, 0), (0, 1), (1, 0)] {
+                let newR = row + r, newC = col + c
+                if newR < 0 || newR >= m || newC < 0 || newC >= n  {
+                    continue
+                }
+                
+                let cellVal = grid[newR][newC]
+                let newRemainingRemoval = cellVal == 0 ? remainingRemoval : remainingRemoval - 1
+                if newRemainingRemoval < 0 || visitedGrid[newR][newC][newRemainingRemoval] != -1  {
+                    continue
+                }
+                
+                visitedGrid[newR][newC][newRemainingRemoval] = 0 // marking this cell as visited
+                queue.append((newR, newC, currentSteps + 1, newRemainingRemoval))
+            }
+        }
+        return minSteps == Int.max ? -1 : minSteps
+    }
+}

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/1487_Making_File_Names_Unique.swift

@@ -0,0 +1,79 @@
+// Linear search. Time: O(n^2). TLE for big input
+class Solution {
+    func getFolderNames(_ names: [String]) -> [String] {
+        var counter = [String:Int]()
+        var result = [String]()
+        for name in names {
+            if counter[name] == nil {
+                counter[name, default: 0] += 1
+                result.append(name)
+                continue
+            }
+            var k = counter[name]!, newName = "\(name)(\(k))"
+            while counter[newName] != nil {
+                k += 1
+                newName = "\(name)(\(k))"
+            }
+            counter[newName, default: 0] += 1
+            result.append(newName)
+        }
+        return result
+    }
+}
+
+// Linear search. Time: O(n^2). Similar to mi above one but it's accepted. No idea why?  https://tinyurl.com/yy9kwrbm
+class Solution {
+    func getFolderNames(_ names: [String]) -> [String] {
+        var dict : [String:Int] = [:]
+        var res : [String] = []
+        for n in names{
+            if dict[n] == nil{
+                dict[n] = 0
+                res.append(n)
+            }
+            else{
+                if dict[n] != nil{
+                    var i = dict[n]! + 1
+                    var val = n + String("(\(i))")
+                    while(dict[val] != nil) {
+                        i += 1
+                        val = n + String("(\(i))")
+                    }
+                    dict[n] = i
+                    dict[val] = 0
+                    res.append(val)
+                }
+            }
+        }
+        return res
+    }
+}
+
+// Binary search. Time: O(n). Wrong answer for some cases
+class Solution {
+    func getFolderNames(_ names: [String]) -> [String] {
+        var counter = [String:Int]()
+        var result = [String]()
+        for name in names {
+            if counter[name] == nil {
+                counter[name, default: 0] += 1
+                result.append(name)
+                continue
+            }
+            var startK = counter[name]!, endK = names.count
+            while startK < endK {
+                let midK = startK + ((endK - startK) / 2)
+                let newName = "\(name)(\(midK))"
+                if counter[newName] == nil {
+                    endK = midK
+                } else {
+                    startK = midK + 1
+                }
+            }
+            let newName = "\(name)(\(startK))"
+            counter[newName, default: 0] += 1
+            result.append(newName)
+        }
+        return result
+    }
+}

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/1642_Furthest_Building_You_Can_Reach.swift

@@ -0,0 +1,25 @@
+import Foundation
+
+// Min Heap
+class Solution {
+    func furthestBuilding(_ heights: [Int], _ bricks: Int, _ ladders: Int) -> Int {
+        var currentLadderAllocationMinHeap = Heap<Int>(sort: <), currentBrickAllocation = 0 //SOURCE:   https://github.com/raywenderlich/swift-algorithm-club/blob/master/Heap/Heap.swift
+        for index in 0..<heights.count - 1 {
+            let currentHeight = heights[index], nextHeight = heights[index + 1], climb = nextHeight - currentHeight
+            if climb <= 0 {
+                continue
+            }
+            currentLadderAllocationMinHeap.insert(climb)
+            if currentLadderAllocationMinHeap.count <= ladders {
+                continue
+            }
+            let neededBricks = currentLadderAllocationMinHeap.remove()!
+            currentBrickAllocation += neededBricks
+            if currentBrickAllocation > bricks {
+                return index
+            }
+        }
+        return heights.count - 1
+    }
+}
+

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/1870_Minimum_Speed_to_Arrive_on_Time.swift

@@ -0,0 +1,31 @@
+
+// Getting TLE for some test cases due to infinit loop. No idea what's going wrong here, though spent a lot of time to figure it out
+import Foundation
+class Solution {
+    func minSpeedOnTime(_ dist: [Int], _ hour: Double) -> Int {
+        var minSpeed = 1, maxSpeed = dist.max()!
+        while minSpeed < maxSpeed {
+            let midSpeed = ((minSpeed + (maxSpeed - minSpeed)) / 2) + 1
+            let totalTime = getTotalTimeFor(midSpeed, dist, hour)
+            if totalTime > hour {
+                minSpeed = midSpeed + 1
+            } else {
+                maxSpeed = midSpeed
+            }
+        }
+        return getTotalTimeFor(minSpeed, dist, hour) <= hour ? minSpeed : -1
+    }
+    
+    func getTotalTimeFor(_ speed: Int, _ dist: [Int], _ hour: Double) -> Double {
+        var totalTime = 0.0
+        for distance in dist {
+            let currentTime = Double(Double(distance)/Double(speed))
+            if distance == dist.last! {
+                totalTime += currentTime
+            } else {
+                totalTime += currentTime.rounded(.up)
+            }
+        }
+        return totalTime
+    }
+}