New Problems

Array/ContainerWithMostWater.swift

@@ -0,0 +1,44 @@
+
+// You are given an integer array height of length n. There are n vertical lines drawn such that the two endpoints of the ith line are (i, 0) and (i, height[i]).
+
+// Find two lines that together with the x-axis form a container, such that the container contains the most water.
+
+// Return the maximum amount of water a container can store.
+
+// Notice that you may not slant the container.
+
+// Input: height = [1,8,6,2,5,4,8,3,7]
+// Output: 49
+// Explanation: The above vertical lines are represented by array [1,8,6,2,5,4,8,3,7]. In this case, the max area of water (blue section) the container can contain is 49.
+// Example 2:
+
+// Input: height = [1,1]
+// Output: 1
+// https://leetcode.com/problems/container-with-most-water/
+
+
+
+class Solution {
+    func maxArea(_ height: [Int]) -> Int {
+        var maxArea = 0
+        var startPointer = 0
+        var endPointer = height.count - 1
+
+        while (startPointer < endPointer) {
+            let minHeight = min(height[startPointer],height[endPointer])
+            let distance = endPointer - startPointer
+            let area = minHeight * distance
+            if area > maxArea {
+                maxArea = area
+            }
+
+            if height[startPointer] < height[endPointer] {
+                startPointer += 1
+            }else{
+                endPointer -= 1
+            }
+        }
+
+        return maxArea
+    }
+}

Array/Kadane'sAlgo_maxSubarray.swift

@@ -0,0 +1,30 @@
+/*
+Given an integer array nums, find the contiguous subarray (containing at least one number) which has the largest sum and return its sum.
+A subarray is a contiguous part of an array.
+
+Example 1:
+Input: nums = [-2,1,-3,4,-1,2,1,-5,4]
+Output: 6
+Explanation: [4,-1,2,1] has the largest sum = 6.
+
+Kadanes algo
+https://medium.com/@rsinghal757/kadanes-algorithm-dynamic-programming-how-and-why-does-it-work-3fd8849ed73d
+*/
+
+
+class Solution {
+    func maxSubArray(_ nums: [Int]) -> Int {
+        let size = nums.count
+        var localMax = 0
+        var globalMax = Int.min
+
+        for i in 0 ..< size {
+            localMax = max(nums[i],nums[i] + localMax)
+            if localMax > globalMax{
+                globalMax = localMax
+            }
+        }
+
+        return globalMax
+    }
+}

Array/LongestSubArraySlidingWindow.swift

@@ -0,0 +1,40 @@
+//
+//  LongestSubArraySlidingWindow.swift
+//  
+//
+//  Created by Tarun Kaushik on 19/10/21.
+//
+
+func findLongestSubArrayUsingSlidingWindow(array:[Int],s: Int) -> [Int] {
+    var window = [Int]()
+    var arraySum = 0
+    var largestArray = [Int]()
+
+    for i in array {
+        // update the array sum and append on window
+        arraySum += i
+        window.append(i)
+
+        // check if the arraysum become more than the required sum
+        if arraySum > s {
+            // if yes than remove the first element from the window till the array sum is greater than required sum
+            while arraySum > s {
+                let firstElement = window[0]
+                arraySum -= firstElement
+                window.removeFirst()
+            }
+        }
+
+        // check if sum is equal than update the largest array
+        if arraySum == s {
+            if largestArray.count < window.count {
+                largestArray = window
+            }
+        }
+    }
+
+    return largestArray
+}
+
+print(findLongestSubArrayUsingSlidingWindow(array: [1,2,4,3,0,0,0,0,10], s: 10))
+

DataStructure/LinkedList/CacheLRU.swift

@@ -0,0 +1,126 @@
+typealias LinkedListNode<T> = DoublyLinkedList<T>.Node<T>
+
+final class DoublyLinkedList<T>{
+
+    final class Node<T> {
+        var payload: T
+        var previous: Node<T>?
+        var next: Node<T>?
+
+        init(payload: T){
+            self.payload = payload
+        }
+    }
+
+    private(set) var count:Int = 0
+    private(set) var head: Node<T>?
+    private(set) var tail: Node<T>?
+
+    func addToHead(_ payload: T) -> Node<T>{
+        let node = Node(payload: payload)
+        defer{
+            head = node
+            count += 1
+        }
+
+        guard let head = head else {
+            tail = node
+            return node
+        }
+
+        head.previous = node
+
+        node.next = head
+        node.previous = nil
+
+        return node
+    }
+
+    func moveToHead(node: Node<T>?) {
+        guard node !== head else {return}
+        let next = node?.next
+        let previous = node?.previous
+
+        previous?.next = next
+        next?.previous = previous
+
+        node?.previous = nil
+        node?.next = head
+
+        if tail === node {
+            tail = previous
+        }
+
+        self.head = node
+    }
+
+    func removeLast() -> Node<T>?{
+        guard let tail = tail else {return nil}
+
+        let previous = tail.previous
+        previous?.next = nil
+        self.tail = previous
+
+        if count == 1{
+            head = nil
+        }
+
+        count -= 1
+
+        return tail
+    }
+}
+
+final class CacheLRU<Key: Hashable,Value>{
+
+    private struct CachePayload{
+        let key: Key
+        let value: Value
+    }
+
+    private let list = DoublyLinkedList<CachePayload>()
+    private var nodeDict = [Key: LinkedListNode<CachePayload>]()
+
+    private let capacity: Int
+
+    init(capacity: Int){
+        self.capacity = capacity
+    }
+
+    func setValue(_ value: Value,for key: Key) {
+        let payload = CachePayload(key:key,value:value)
+        let node = LinkedListNode(payload:payload)
+
+        if let existingNode = nodeDict[key] {
+            existingNode.payload = payload
+            list.moveToHead(node:existingNode)
+        }else{
+            list.addToHead(payload)
+            nodeDict[key] = node
+        }
+
+        if list.count > capacity{
+            let removedNode = list.removeLast()
+            if let key = removedNode?.payload.key{
+                 nodeDict[key] = nil
+            }
+        }
+    }
+
+    func getValue(for key: Key) -> Value?{
+        guard let node = nodeDict[key] else {return nil}
+        list.moveToHead(node:node)
+        return node.payload.value
+    }
+}
+
+let cache = CacheLRU<Int, String>(capacity: 2)
+
+cache.getValue(for: 5) // nil
+
+cache.setValue("One", for: 1)
+cache.setValue("Eleven", for: 11)
+cache.setValue("Twenty", for: 20)
+
+cache.getValue(for: 1) // nil. We exceeded the capacity with the previous `setValue`  and `1` was the last element.
+cache.getValue(for: 11) // Eleven

DataStructure/LinkedList/LinkList.swift

@@ -0,0 +1,136 @@
+class LinkedListNode<T> {
+    var value: T
+    weak var previous: LinkedListNode?
+    var next: LinkedListNode?
+
+    init(value: T) {
+        self.value = value
+    }
+}
+
+
+class LinkList<T> {
+    typealias Node = LinkedListNode<T>
+
+    var head: Node?
+    var tail: Node? {
+        if last === head {
+            return nil
+        }
+        return last
+    }
+
+    var isEmpty: Bool {
+        return head == nil
+    }
+
+    var first: Node? {
+        return head
+    }
+
+    var last: Node? {
+        guard var node = head else {return nil}
+
+        while let next = node.next {
+            node = next
+        }
+
+        return node
+    }
+
+    var count: Int {
+        guard var node = head else { return 0}
+
+        var count = 1
+
+        while let next = node.next{
+            node = next
+            count += 1
+        }
+
+        return count
+    }
+
+    func print() {
+        guard var node = head else {Swift.print("empty"); return}
+        var str = "Head(\(node.value))"
+
+        while let next = node.next {
+            node = next
+            str += next.next == nil ? " -> Tail(\(next.value))" : " -> (\(next.value))"
+        }
+
+        Swift.print(str)
+    }
+
+    func append(value : T) {
+        let newNode = Node(value: value)
+
+        if let lastNode = last {
+            newNode.previous = lastNode
+            lastNode.next = newNode
+        } else {
+            head = newNode
+        }
+    }
+
+    func reverse() {
+        var node = head
+
+        while let currentNode = node {
+            node = currentNode.next
+            // swap the previous and next references
+            let previous = currentNode.previous
+            currentNode.previous = node
+            currentNode.next = previous
+            head = currentNode
+        }
+    }
+
+    func insert(atIndex index: Int, value: T) {
+        let newNode = Node(value: value)
+
+        if index == 0 {
+            newNode.next = head
+            head?.previous = newNode
+            head = newNode
+        } else {
+            let prev = self.node(atIndex: index - 1 )
+            let next = prev.next
+
+            newNode.previous = prev
+            newNode.next = next
+            prev.next = newNode
+            next?.previous = newNode
+        }
+    }
+
+    func node(atIndex index: Int) -> Node {
+        if index == 0 {
+            return head!
+        } else {
+            var node = head!.next
+
+            for _ in 1 ..< index {
+                node = node?.next
+                if node == nil {
+                    break
+                }
+            }
+
+            return node!
+        }
+    }
+}
+
+let list = LinkList<String>()
+list.isEmpty
+list.first
+list.append(value: "Test1")
+list.append(value: "Test2")
+list.append(value: "Test3")
+list.last?.value
+list.count
+//list.insert(atIndex: 1, value: "Func")
+//list.node(atIndex: 2)
+//list.print()