multiple solution

Author: partho-maple

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/1091_Shortest_Path_in_Binary_Matrix.swift

@@ -0,0 +1,23 @@
+class Solution {
+    func shortestPathBinaryMatrix(_ grid: [[Int]]) -> Int {
+        var copyGrid = grid, n = grid.count, queue = [(Int, Int, Int)](), minLength = Int.max
+        queue.append((0, 0 ,1))
+        while !queue.isEmpty {
+            let (row, col, length) = queue.removeFirst()
+            if row == n - 1 && col == n - 1 {
+                minLength = length
+                queue.removeAll()
+                break
+            }
+            for (r, c) in [(0, -1), (-1, 0), (0, 1), (1, 0), (-1, -1), (-1, 1), (1, 1), (1, -1)] {
+                let (newR, newC) = (row + r, col + c)
+                if newR < 0 || newR >= copyGrid.count || newC < 0 || newC >= copyGrid[0].count || copyGrid[newR][newC] != 0 {
+                    continue
+                }
+                copyGrid[newR][newC] = 2
+                queue.append((newR, newC, length + 1))
+            }
+        }
+        return minLength
+    }
+}

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/1944_Number_of_Visible_People_in_a_Queue.swift

@@ -0,0 +1,40 @@
+// Brute Force. Time: O(n^2). TLE
+class Solution {
+    func canSeePersonsCount(_ heights: [Int]) -> [Int] {
+        var visible = Array(repeating: 0, count: heights.count)
+        for index in 0..<heights.count - 1 {
+            var currentMax = Int.min
+            for index2 in (index + 1)..<heights.count {
+                if heights[index] < heights[index2] {
+                    visible[index] += 1
+                    break
+                } else if heights[index] > heights[index2] && heights[index2] > currentMax {
+                    visible[index] += 1
+                    currentMax = heights[index2]
+                }
+            }
+        }
+        return visible
+    }
+}
+
+// Increasing monotonic stack. Time: O(n). Accepted. https://tinyurl.com/y598x5s3
+class Solution {
+    func canSeePersonsCount(_ heights: [Int]) -> [Int] {
+        guard heights.count > 1 else {
+            return [0]
+        }
+        var visible = Array(repeating: 0, count: heights.count), incMonoStack = [Int]()
+        for index in stride(from: heights.count - 1, through: 0, by: -1) {
+            while !incMonoStack.isEmpty && heights[index] > incMonoStack.last! {
+                incMonoStack.removeLast()
+                visible[index] += 1
+            }
+            if !incMonoStack.isEmpty {
+                visible[index] += 1
+            }
+            incMonoStack.append(heights[index])
+        }
+        return visible
+    }
+}

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/224_Basic_Calculator.swift

@@ -0,0 +1,56 @@
+class Solution {
+    func calculate(_ s: String) -> Int {
+        let sArray = Array(s)
+        var stack = [String](), currentNumber = [Character]()
+        for item in sArray {
+            if item.isNumber {
+                currentNumber.append(item)
+            } else if !currentNumber.isEmpty {
+                let number = currentNumber.map { String($0) }.reduce("") { $0 + $1 }
+                stack.append(number)
+                currentNumber.removeAll()
+            }
+            if item == " " {
+                continue
+            }
+            if item == "+" || item == "-" || item == "(" {
+                stack.append(String(item))
+            }
+            if item == ")" {
+                var subExp = [String]()
+                while stack.last! != "(" {
+                    subExp.append(stack.removeLast())
+                }
+                stack.removeLast() // removes last "(" character
+                let currentValue = evalExpression(subExp.reversed())
+                stack.append(String(currentValue)) // Adds back the calculated number
+            }
+        }
+        
+        if !currentNumber.isEmpty {
+            let number = currentNumber.map { String($0) }.reduce("") { $0 + $1 }
+            stack.append(number)
+            currentNumber.removeAll()
+        }
+        return evalExpression(stack)
+    }
+    
+    func evalExpression(_ exp: [String]) -> Int {
+        var prevNumber = 0, prevSign = "+"
+        for item in exp {
+            if item == "+" || item == "-" {
+                prevSign = item
+                continue
+            }
+            
+            var newNum = 0
+            if prevSign == "+" {
+                newNum = Int(prevNumber) + Int(item)!
+            } else {
+                newNum = Int(prevNumber) - Int(item)!
+            }
+            prevNumber = newNum
+        }
+        return prevNumber
+    }
+}

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/515_Find_Largest_Value_in_Each_Tree_Row.swift

@@ -0,0 +1,25 @@
+class Solution {
+    func largestValues(_ root: TreeNode?) -> [Int] {
+        guard let root = root else {
+            return []
+        }
+        var result = [Int](), queue = [TreeNode]()
+        queue.append(root)
+        while !queue.isEmpty {
+            var currentMax = Int.min
+            let currentLevelLength = queue.count
+            for i in 0..<currentLevelLength {
+                let node = queue.removeFirst()
+                currentMax = max(currentMax, node.val)
+                if let left = node.left {
+                    queue.append(left)
+                }
+                if let right = node.right {
+                    queue.append(right)
+                }
+            }
+            result.append(currentMax)
+        }
+        return result
+    }
+}

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/556_Next_Greater_Element_III.swift

@@ -0,0 +1,30 @@
+class Solution {
+    func nextGreaterElement(_ n: Int) -> Int {
+        var nArray = Array(String(n))
+        guard nArray.count >= 2 else {
+            return -1
+        }
+        var prevIdx = nArray.count - 1
+        for currIdx in stride(from: nArray.count - 2, through: 0, by: -1) {
+            prevIdx = currIdx + 1
+            if nArray[prevIdx] > nArray[currIdx] {
+                var swapIdx = nArray.count - 1
+                while swapIdx > currIdx {
+                    if nArray[currIdx] < nArray[swapIdx] {
+                        nArray.swapAt(swapIdx, currIdx)
+                        nArray = Array(nArray[0...currIdx]) + Array(nArray[prevIdx..<nArray.count]).reversed()
+                        let result = Int(nArray.map { String($0) }.reduce("") { $0 + $1 })!
+                        if result < Int32.max {
+                            return result
+                        } else {
+                            return -1
+                        }
+                    } else {
+                        swapIdx -= 1
+                    }
+                }
+            }
+        }
+        return -1
+    }
+}