deploy: fb2df73

Author: boudhayan

.nojekyll

@@ -0,0 +1,56 @@
+//
+//  ApartmentHunting+.swift
+//  Algorithm Solutions In Swift
+//
+//  Created by Boudhayan Biswas on 25/03/22.
+//
+
+import Foundation
+
+// T: O(BR), S: O(BR)
+func apartmentHunting1(_ blocks: [[String: Bool]], _ requirements: [String]) -> Int {
+    var distances = [[Int]]()
+    for idx in stride(from: 0, to: requirements.count, by: 1) {
+        distances.append(findDistances(for: requirements[idx], blocks: blocks))
+    }
+    var minDistance = Int(Int32.max)
+    var nearestIndex = -1
+    for idx in stride(from: 0, to: distances[0].count, by: 1) {
+        var maxDistance = Int(Int32.min)
+        for rdx in stride(from: 0, to: requirements.count, by: 1) {
+            maxDistance = max(maxDistance, distances[rdx][idx])
+        }
+        if maxDistance < minDistance {
+            minDistance = maxDistance
+            nearestIndex = idx
+        }
+    }
+    
+    return nearestIndex
+}
+
+func findDistances(for requirement: String, blocks: [[String: Bool]]) -> [Int] {
+    var distances = Array(repeating: Int(Int32.min), count: blocks.count)
+    var previous = Int(Int32.min)
+    for idx in stride(from: 0, to: blocks.count, by: 1) {
+        let block = blocks[idx]
+        if let isReqExists = block[requirement], isReqExists {
+            distances[idx] = 0
+            previous = 0
+        } else {
+            if previous >= 0 {
+                distances[idx] = distances[idx - 1] + 1
+                previous = distances[idx]
+            }
+        }
+    }
+    
+    for idx in stride(from: distances.count - 2, through: 0, by: -1) {
+        if distances[idx] < 0 {
+            distances[idx] = distances[idx + 1] + 1
+        } else {
+            distances[idx] = min(distances[idx + 1] + 1, distances[idx])
+        }
+    }
+    return distances
+}

AlgoExpert/Apartment Hunting/ApartmentHunting+.swift

@@ -0,0 +1,32 @@
+//
+//  ApartmentHunting.swift
+//  Algorithm Solutions In Swift
+//
+//  Created by Boudhayan Biswas on 25/03/22.
+//
+
+import Foundation
+
+// T: O(B^2R), S: O(1)
+func apartmentHunting(_ blocks: [[String: Bool]], _ requirements: [String]) -> Int {
+    var nearestIdx = -1
+    var distance = Int(Int32.max)
+    for idx in stride(from: 0, to: blocks.count, by: 1) {
+        var maximumDistance = Int(Int32.min)
+        for req in requirements {
+            var minimumDistance = Int(Int32.max)
+            for jdx in stride(from: 0, to: blocks.count, by: 1) {
+                let block = blocks[jdx]
+                if let isExist = block[req], isExist {
+                    minimumDistance = min(minimumDistance, abs(jdx - idx))
+                }
+            }
+            maximumDistance = max(maximumDistance, minimumDistance)
+        }
+        if maximumDistance < distance {
+            distance = maximumDistance
+            nearestIdx = idx
+        }
+    }
+    return nearestIdx
+}

AlgoExpert/Apartment Hunting/ApartmentHunting.swift

@@ -0,0 +1,31 @@
+//
+//  ArrayOfProducts.swift
+//  Algorithm Solutions In Swift
+//
+//  Created by Boudhayan Biswas on 18/07/21.
+//
+
+import Foundation
+
+/**
+ Time Complexity: O(n)
+ Space Complexity: O(n)
+ Note: 
+ */
+func arrayOfProducts(_ array: [Int]) -> [Int] {
+    var products = Array(repeating: 1, count: array.count)
+    var leftRunningProducts = Array(repeating: 1, count: array.count)
+    var rightRunningProducts = Array(repeating: 1, count: array.count)
+    for idx in stride(from: 1, to: array.count, by: 1) {
+        leftRunningProducts[idx] = leftRunningProducts[idx - 1] * array[idx - 1]
+    }
+    
+    for idx in stride(from: array.count - 2, through: 0, by: -1) {
+        rightRunningProducts[idx] = rightRunningProducts[idx + 1] * array[idx + 1]
+    }
+    
+    for idx in stride(from: 0, to: array.count, by: 1) {
+        products[idx] = leftRunningProducts[idx] * rightRunningProducts[idx]
+    }
+    return products
+}

AlgoExpert/Array of Products/ArrayOfProducts.swift

@@ -0,0 +1,117 @@
+//
+//  BSTConstruction.swift
+//  Algorithm Solutions In Swift
+//
+//  Created by Boudhayan Biswas on 24/07/21.
+//
+
+import Foundation
+
+extension BinarySearchTree {
+    /**
+     Time Complexity: O(logn)
+     Space Complexity: O(1)
+     Note:
+     */
+    func insert(value: Int) -> BinarySearchTree {
+        var currentNode: BinarySearchTree? = self
+        while let node = currentNode {
+            if value < node.value {
+                if node.left == nil {
+                    node.left = BinarySearchTree(value: value)
+                    break
+                } else {
+                    currentNode = node.left
+                }
+            } else {
+                if node.right == nil {
+                    node.right = BinarySearchTree(value: value)
+                    break
+                } else {
+                    currentNode = node.right
+                }
+            }
+        }
+        return self
+    }
+    
+    /**
+     Time Complexity: O(logn)
+     Space Complexity: O(1)
+     Note:
+     */
+    func contains(value: Int) -> Bool {
+        var currentNode: BinarySearchTree? = self
+        while let node = currentNode {
+            if value < node.value {
+                currentNode = node.left
+            } else if value > node.value {
+                currentNode = node.right
+            } else {
+               return true
+            }
+        }
+        return false
+    }
+    
+    /**
+     Time Complexity: O(logn)
+     Space Complexity: O(1)
+     Note:
+     */
+    func remove(value: Int, parentNode: BinarySearchTree?) -> BinarySearchTree {
+        var currentNode: BinarySearchTree? = self
+        var parent = parentNode
+        while let node = currentNode {
+            if value < node.value {
+                parent = currentNode
+                currentNode = node.left
+            } else if value > node.value {
+                parent = currentNode
+                currentNode = node.right
+            } else {
+                //1. When the nodes to be deleted has both left and right child node
+                //2. When the node to be deleted is the root node (parent node is nil) and it has either left branch or right branch
+                //3. When the node to be deleted has parent node and node to be deleted is either the only left or right child of parent node
+                if let _ = node.left, let rightNode = node.right {
+                    node.value = rightNode.getMinimumValue()
+                    let _ = rightNode.remove(value: node.value, parentNode: node)
+                } else if parent == nil {
+                    if let leftNode = node.left {
+                        node.value = leftNode.value
+                        node.right = leftNode.right
+                        node.left = leftNode.left
+                    } else if let rightNode = node.right {
+                        node.value = rightNode.value
+                        node.left = rightNode.left
+                        node.right = rightNode.right
+                    } else {
+                        
+                    }
+                } else if let parent = parent, node === parent.left {
+                    if let newLeft = node.left {
+                        parent.left = newLeft
+                    } else {
+                        parent.left = node.right
+                    }
+                } else if let parent = parent, node === parent.right {
+                    if let newLeft = node.left {
+                        parent.right = newLeft
+                    } else {
+                        parent.right = node.right
+                    }
+                }
+                break
+            }
+        }
+        return self
+    }
+    
+    func getMinimumValue() -> Int {
+        var currentNode: BinarySearchTree = self
+        while let node = currentNode.left {
+            currentNode = node
+        }
+        return currentNode.value
+    }
+}

AlgoExpert/BST Construction/BSTConstruction.swift

@@ -0,0 +1,59 @@
+//
+//  BSTTraversal.swift
+//  Algorithm Solutions In Swift
+//
+//  Created by Boudhayan Biswas on 19/07/21.
+//
+
+import Foundation
+
+fileprivate class BST {
+    var value: Int
+    var left: BST?
+    var right: BST?
+    
+    init(value: Int) {
+        self.value = value
+    }
+}
+/**
+ Time Complexity: O(n)
+ Space Complexity: O(n)
+ Note:
+ */
+fileprivate func inOrderTraversal(tree: BST?, array: inout [Int]) -> [Int] {
+    if let node = tree {
+        _ = inOrderTraversal(tree: node.left, array: &array)
+        array.append(node.value)
+        _ = inOrderTraversal(tree: node.right, array: &array)
+    }
+    return array
+}
+
+/**
+ Time Complexity: O(n)
+ Space Complexity: O(n)
+ Note:
+ */
+fileprivate func preOrderTraversal(tree: BST?, array: inout [Int]) -> [Int] {
+    if let node = tree {
+        array.append(node.value)
+        _ = preOrderTraversal(tree: node.left, array: &array)
+        _ = preOrderTraversal(tree: node.right, array: &array)
+    }
+    return array
+}
+
+/**
+ Time Complexity: O(n)
+ Space Complexity: O(n)
+ Note:
+ */
+fileprivate func postOrderTraversal(tree: BST?, array: inout [Int]) -> [Int] {
+    if let node = tree {
+        _ = postOrderTraversal(tree: node.left, array: &array)
+        _ = postOrderTraversal(tree: node.right, array: &array)
+        array.append(node.value)
+    }
+    return array
+}

AlgoExpert/BST Traversal/BSTTraversal.swift

@@ -0,0 +1,50 @@
+//
+//  BalancedBrackets.swift
+//  Algorithm Solutions In Swift
+//
+//  Created by Boudhayan Biswas on 31/03/22.
+//
+
+import Foundation
+
+// T: O(N), S: O(N)
+func balancedBrackets(string: String) -> Bool {
+    var stack = [Character]()
+    for char in string {
+        if char == ")" || char == "}" || char == "]" {
+            let lastBracket = pop(&stack)
+            if lastBracket != openingBracket(for: char) {
+                return false
+            }
+        } else {
+            _ = push(char, &stack)
+        }
+    }
+    return stack.isEmpty
+}
+
+func push(_ char: Character, _ stack: inout [Character]) -> Bool {
+    if char == "(" || char == "{" || char == "[" {
+        stack.append(char)
+        return true
+    }
+    return false
+}
+
+func pop(_ stack: inout [Character]) -> Character? {
+    guard !stack.isEmpty else { return nil }
+    return stack.removeLast()
+}
+
+func openingBracket(for bracket: Character) -> Character {
+    if bracket == ")" {
+        return "("
+    } else if bracket == "}" {
+        return "{"
+    } else if bracket == "]" {
+        return "["
+    } else {
+        // this should not come here
+    }
+    return "."
+}

AlgoExpert/Balanced Brackets/BalancedBrackets.swift

@@ -0,0 +1,29 @@
+//
+//  BinarySearch.swift
+//  Algorithm Solutions In Swift
+//
+//  Created by Boudhayan Biswas on 17/07/21.
+//
+
+import Foundation
+
+/**
+ Time Complexity: O(logn)
+ Space Complexity: O(logn)
+ Note: 
+ */
+func binarySearch(array: [Int], target: Int) -> Int {
+    return binarySearchHelper(array: array, target: target, start: 0, end: array.count - 1)
+}
+
+func binarySearchHelper(array: [Int], target: Int, start: Int, end: Int) -> Int {
+    if start > end { return -1 }
+    let mid = start + (end - start) / 2
+    if target < array[mid] {
+        return binarySearchHelper(array: array, target: target, start: start, end: mid - 1)
+    } else if target > array[mid] {
+        return binarySearchHelper(array: array, target: target, start: mid + 1, end: end)
+    } else {
+        return mid
+    }
+}