10 problems

Author: partho-maple

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/1249_Minimum_Remove_to_Make_Valid_Parentheses.swift

@@ -28,3 +28,43 @@ class Solution {
  return resultString
  }
 }
+
+
+
+class Solution {
+ func minRemoveToMakeValid(_ s: String) -> String {
+ var sArray = Array(s), stack = [Character](), leftCount = 0, rightCount = 0
+
+ for item in sArray {
+ if item == "(" {
+ stack.append(item)
+ leftCount += 1
+ } else if item == ")" {
+ if leftCount > 0 {
+ stack.append(item)
+ leftCount -= 1
+ }
+ } else {
+ stack.append(item)
+ }
+ }
+ 
+ sArray = stack
+ stack.removeAll()
+ 
+ for item in sArray.reversed() {
+ if item == "(" {
+ if rightCount > 0 {
+ stack.append(item)
+ rightCount -= 1
+ }
+ } else if item == ")" {
+ stack.append(item)
+ rightCount += 1
+ } else {
+ stack.append(item)
+ }
+ }
+ return stack.reversed().reduce("") { $0 + String($1) }
+ }
+}

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/1541_Minimum_Insertions_to_Balance_a_Parentheses_String.swift

@@ -0,0 +1,35 @@
+class Solution {
+ func minInsertions(_ s: String) -> Int {
+ let sArray = Array(s)
+ var stack = [Int](), result = 0
+ for item in sArray {
+ if item == "(" {
+ if let last = stack.last {
+ if last == 2 {
+ stack.append(2)
+ } else {
+ result += 1
+ stack.removeLast()
+ stack.append(2)
+ }
+ } else {
+ stack.append(2)
+ }
+ } else {
+ if let last = stack.last {
+ if last == 2 {
+ stack.removeLast()
+ stack.append(1)
+ } else {
+ stack.removeLast()
+ }
+ } else {
+ result += 1
+ stack.append(1)
+ }
+ }
+ }
+ result += stack.reduce(0) { $0 + $1 }
+ return result
+ }
+}

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/1559_Detect_Cycles_in_2D_Grid.swift

@@ -0,0 +1,39 @@
+// Main Idea: https://tinyurl.com/y4dtahmr
+class Solution {
+ func containsCycle(_ grid: [[Character]]) -> Bool {
+ var visited = Array(repeating: Array(repeating: false, count: grid[0].count), count: grid.count)
+ for i in 0..<grid.count {
+ for j in 0..<grid[0].count {
+ if !visited[i][j] {
+ if containsCycleHelperDFS(grid, i, j, &visited, -1, -1) {
+ return true
+ }
+ }
+ }
+ }
+ return false
+ }
+ 
+ func containsCycleHelperDFS(_ grid: [[Character]], _ row: Int, _ col: Int, _ visited: inout [[Bool]], _ prevRow: Int, _ prevCol: Int) -> Bool {
+ for (r, c) in [(0, -1), (-1, 0), (0, 1), (1, 0)] {
+ let (newR, newC) = (row + r, col + c)
+ if newR < 0 || newR >= grid.count || newC < 0 || newC >= grid[0].count {
+ continue
+ }
+ if newR == prevRow && newC == prevCol {
+ continue
+ }
+ if grid[newR][newC] == grid[row][col] {
+ if visited[newR][newC] {
+ return true
+ } else {
+ visited[newR][newC] = true
+ if containsCycleHelperDFS(grid, newR, newC, &visited, row, col) {
+ return true
+ }
+ }
+ }
+ }
+ return false
+ }
+}

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/1762_Buildings_With_an_Ocean_View.swift

@@ -0,0 +1,13 @@
+class Solution {
+ func findBuildings(_ heights: [Int]) -> [Int] {
+ var result = [Int](), currentMaxHeight = Int.min
+ for i in stride(from: heights.count - 1, through: 0, by: -1) {
+ let currentHeight = heights[i]
+ if currentHeight > currentMaxHeight {
+ result.append(i)
+ currentMaxHeight = currentHeight
+ }
+ }
+ return result.reversed()
+ }
+}

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/314_Binary_Tree_Vertical_Order_Traversa.swift

@@ -0,0 +1,71 @@
+import Foundation
+
+/**
+ * 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
+ * }
+ * }
+ */
+
+// DFS. Wrong answer
+class Solution {
+ func verticalOrder(_ root: TreeNode?) -> [[Int]] {
+ var heightNodeMap = [Int:[Int]]()
+ verticalOrderDFSHelper(root, 0, &heightNodeMap)
+ 
+ var result = [[Int]]()
+ for key in heightNodeMap.keys.sorted() {
+ result.append(heightNodeMap[key]!.sorted())
+ }
+ return result
+ }
+ 
+ func verticalOrderDFSHelper(_ root: TreeNode?, _ horrizotalDistace: Int, _ heightNodeMap: inout [Int:[Int]]) {
+ guard let root = root else {
+ return
+ }
+ 
+ heightNodeMap[horrizotalDistace, default: [Int]()].append(root.val)
+ verticalOrderDFSHelper(root.left, horrizotalDistace - 1, &heightNodeMap)
+ verticalOrderDFSHelper(root.right, horrizotalDistace + 1, &heightNodeMap)
+ }
+}
+
+// BFS. Accepted
+class Solution {
+ func verticalOrder(_ root: TreeNode?) -> [[Int]] {
+ guard let root = root else {
+ return []
+ }
+ var heightNodeMap = [Int:[Int]]()
+ var queue = [(TreeNode, Int)]() // (TreeNode, horrizotalDistace)
+ queue.append((root, 0))
+ 
+ while !queue.isEmpty {
+ let (node, horrizotalDistace) = queue.removeFirst()
+ heightNodeMap[horrizotalDistace, default: [Int]()].append(node.val)
+ if let left = node.left {
+ queue.append((left, horrizotalDistace - 1))
+ }
+ 
+ if let right = node.right {
+ queue.append((right, horrizotalDistace + 1))
+ }
+ }
+ 
+ var result = [[Int]](), minHorrizotalDistace = heightNodeMap.keys.min()!, maxHorrizotalDistace = heightNodeMap.keys.max()!
+ for key in minHorrizotalDistace...maxHorrizotalDistace {
+ result.append(heightNodeMap[key]!)
+ }
+ return result
+ }
+}

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/426_Convert_Binary_Search_Tree_to_Sorted_Doubly_Linked_List.swift

@@ -12,7 +12,6 @@ public class Node {
  }
 }
 
-import Foundation
 class Solution {
  func treeToDoublyList(_ root: Node?) -> Node? {
  guard let rootNode = root else {
@@ -41,3 +40,32 @@ class Solution {
  treeToDoublyListInorderDFSHelper(rootNode.right, &listHead, &listTail)
  }
 }
+
+// More cleaner version than the above
+class Solution {
+ func treeToDoublyList(_ root: Node?) -> Node? {
+ guard let root = root else {
+ return nil
+ }
+ var first: Node? = nil, last: Node? = nil // first is the smallest and last is the largest
+ treeToDoublyListInorderDFSHelper(root, &first, &last)
+ first!.left = last
+ last!.right = first
+ return first
+ }
+ 
+ func treeToDoublyListInorderDFSHelper(_ root: Node?, _ first: inout Node?, _ last: inout Node?) {
+ guard let root = root else {
+ return
+ }
+ treeToDoublyListInorderDFSHelper(root.left, &first, &last)
+ if last != nil {
+ root.left = last
+ last!.right = root
+ } else {
+ first = root
+ }
+ last = root
+ treeToDoublyListInorderDFSHelper(root.right, &first, &last)
+ }
+}

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/503_Next_Greater_Element_II.swift

@@ -0,0 +1,17 @@
+// https://tinyurl.com/y6s5neug
+class Solution {
+ func nextGreaterElements(_ nums: [Int]) -> [Int] {
+ var nextGreater = Array(repeating: -1, count: nums.count), stack = [Int]()
+ let len = nums.count
+ for i in stride(from: 2 * len - 1, through: 0, by: -1) {
+ while !stack.isEmpty && stack.last! <= nums[i % len] {
+ stack.removeLast()
+ }
+ if !stack.isEmpty && i < len {
+ nextGreater[i] = stack.last!
+ }
+ stack.append(nums[i % len])
+ }
+ return nextGreater
+ }
+}

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/528_Random_Pick_with_Weight.swift

@@ -0,0 +1,30 @@
+import Foundation
+
+// Video: https://tinyurl.com/y5bhfoze
+class Solution {
+ var prefixSum = [Int]()
+ init(_ w: [Int]) {
+ for i in 0..<w.count {
+ if i == 0 {
+ prefixSum.append(w[i])
+ } else {
+ prefixSum.append(prefixSum.last! + w[i])
+ }
+ }
+ }
+ 
+ func pickIndex() -> Int {
+ let randWeight = Int.random(in: 1...prefixSum.last!)
+ var left = 0, right = prefixSum.count - 1
+ while left < right {
+ let mid = left + (right - left) / 2
+ if prefixSum[mid] < randWeight {
+ left = mid + 1
+ } else {
+ right = mid
+ }
+ }
+ 
+ return left
+ }
+}

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/560_Subarray_Sum_Equals_K.swift

@@ -1,21 +1,40 @@
 import Foundation
 
+// Time: O(n^2)
 class Solution {
  func subarraySum(_ nums: [Int], _ k: Int) -> Int {
- guard nums.count > 0 else {
- return 0
+ var prefixSum = [Int]()
+ prefixSum.append(0)
+ for num in nums {
+ prefixSum.append(prefixSum.last! + num)
+ }
+ 
+ var count = 0
+ for i in 0..<nums.count {
+ for j in i..<nums.count {
+ if prefixSum[j + 1] - prefixSum[i] == k {
+ count += 1
+ }
+ }
  }
- var prefixSumCounter = [Int:Int]()
- prefixSumCounter[0] = 1
- var (subarrayCount, currentSum) = (0, 0)
+ return count
+ }
+}
+
+// Time: O(n)
+import Foundation
+class Solution {
+ func subarraySum(_ nums: [Int], _ k: Int) -> Int {
+ var prefixSumCounterMap = [Int:Int](), totalCount = 0, currentSum = 0
+ prefixSumCounterMap[0] = 1
  for num in nums {
  currentSum += num
- var prefixSum = currentSum - k
- if let count = prefixSumCounter[prefixSum] {
- subarrayCount += count
+ let prevPrefixSum = currentSum - k
+ if let currentCount = prefixSumCounterMap[prevPrefixSum] {
+ totalCount += currentCount
  }
- prefixSumCounter[currentSum, default: 0] += 1
+ prefixSumCounterMap[currentSum, default: 0] += 1
  }
- return subarrayCount
+ return totalCount
  }
 }

leetcode.com/swift/DS_ALGO_PRAC.playground/Sources/swift/921_Minimum_Add_to_Make_Parentheses_Valid.swift

@@ -16,3 +16,22 @@ class Solution {
  return stack.count
  }
 }
+
+
+class Solution {
+ func minAddToMakeValid(_ s: String) -> Int {
+ var stack = [Character](), count = 0
+ for char in s {
+ if char == Character("(") {
+ stack.append(char)
+ } else if char == Character(")") {
+ if !stack.isEmpty && stack.last! == Character("(") {
+ stack.removeLast()
+ } else {
+ count += 1
+ }
+ }
+ }
+ return count + stack.count
+ }
+}