27/07/21 many back2backSWE questions on a range of topics

Author: OliverIgnetik

Arrays/kth_largest_element.py

@@ -29,7 +29,7 @@ def simple_method(arr, k):
 """
 
 
-def heap_approach(arr, k):
+def heap_approach_kth_largest(arr, k):
     q = PriorityQueue()
     for num in arr:
         q.put(num)
@@ -39,6 +39,16 @@ def heap_approach(arr, k):
     return q.get()
 
 
+def heap_approach_kth_smallest(arr, k):
+    q = PriorityQueue()
+    for num in arr:
+        q.put(-num)
+        if q.qsize() > k:
+            q.get()
+
+    return -q.get()
+
+
 """
 O(N) Approach using partitions 
 Think of BUD (Bottlenecks, Unnecessary work, Duplicate work)
@@ -68,6 +78,8 @@ def heap_approach(arr, k):
 
 def quickselect(arr, k):
     '''
+    Interface
+    ----
     :type arr: list of int
     :type k: int
     :rtype: int
@@ -133,5 +145,5 @@ def swap(arr, first, second):
 
 arr = [8, 1, 3, 2, 6, 7]
 
-print(heap_approach(arr, 2))
+print(heap_approach_kth_smallest(arr, 2))
 print(quickselect(arr, 2))

Graphs/greedy_algorithms/dijkstra_algorithm_adjacency_list.py

@@ -4,7 +4,7 @@
 - https://www.youtube.com/watch?v=jND_WJ8r7FE&list=PLDV1Zeh2NRsB6SWUrDFW2RmDotAfPbeHu&index=52&t=9s WilliamFiset Indexed Priority Queue
 """
 import sys
-sys.path.append('..\\..\\Stacks and Queues')
+sys.path.append('..\\..\\stacksAndQueues')
 
 from queue import PriorityQueue
 from math import inf

Graphs/greedy_algorithms/dijkstra_algorithm_eager_min_dary_heap.py

@@ -1,5 +1,5 @@
 import sys
-sys.path.append('..\\..\\Trees\\heaps')
+sys.path.append('..\\..\\heaps')
 
 from math import inf
 from dary_heap import minIndexedDHeap

Graphs/greedy_algorithms/prims_algorithm_eager_adjacency_list.py

@@ -1,5 +1,5 @@
 import sys
-sys.path.append('../../Stacks and Queues')
+sys.path.append('..\\..\\stacksAndQueues')
 
 from math import inf
 from general_graph import make_complicated_graph2

Hashtables/implementLRUCache.py

@@ -0,0 +1,134 @@
+"""
+Implement An LRU Cache
+An LRU cache is a cache that uses the LRU replacement policy.
+
+The cache has the following api:
+- get(int key): Returns the value corresponding to the key key. 
+If the key does not exist null is returned instead.
+- put(int key, int value): Inserts the key-value pair into the cache.
+If an item with key key already exists then the value will just be updated.
+
+These are the special properties of the cache:
+- When an item is retrieved by key it moves to the conceptual "front" of the cache (it is the most recently used item)
+- When an item is updated it moves to the conceptual "front" of the cache (it is the most recently used item)
+- When a new item is inserted it is inserted to the "front"
+- When the cache goes over-capacity it will remove the least recently used item which will sit at the conceptual "end" 
+of the cache to make room for the new item inserted
+
+Implement an LRU cache.
+"""
+
+
+class LRUNode:
+    def __init__(self, key, value, next=None, prev=None):
+        self.key = key
+        self.value = value
+        self.next = next
+        self.prev = prev
+
+
+class LRUCache:
+    """
+    Approach
+    ----
+    1. Use a linked list they are a better choice then an array because of the shifting of items (O(N)).
+    - Linked Lists are great for removal and insertion
+    - Even if we use a hashtable to index to items there is no way to index to the item before the tail
+    - Doubly Linked Lists would be a better choice as we have the prev pointer. We can use a doubly linked list 
+    in combination with a hashtable to index straight into the items of interest
+    - the keys of values would map to the memory address of the nodes
+
+    NOTE: HASHTABLES CAN AUGMENT MANY DATA STRUCTURES, THE INDEXED PRIORITY QUEUE IS A GREAT EXAMPLE
+
+    2. Time complexities should be on the order:
+    get - O(1)
+    put - O(1)
+
+    3. Model use cases
+    insert - insert item to head of queue
+    remove - remove from the front of the queue 
+    get - move item to front of the queue 
+    update - move item to front of the queue 
+    capacityCheck - if the cache goes over capacity we remove the end of the queue
+    """
+
+    def __init__(self):
+        self.capacity = 0
+        self.maxCapacity = 5
+        # store references to nodes
+        self.hashtable = {}
+        self.head = None
+        self.tail = self.head
+
+    def put(self, key, value):
+        if key not in self.hashtable:
+            # we put it at the front of the queue and place it in the hashtable
+            newNode = LRUNode(key, value)
+            self.hashtable[key] = newNode
+            if self.capacity == 0:
+                self.head = newNode
+                self.capacity += 1
+            else:
+                newNode.next = self.head
+                self.head.prev = newNode
+                self.head = newNode
+                # increment capacity and check
+                self.capacity += 1
+                self.checkCapacity()
+                return
+        else:
+            node_reference = self.hashtable[key]
+            node_reference.value = value
+            self.moveToFront(key)
+            return
+
+    def get(self, key):
+        if key not in self.hashtable:
+            raise KeyError(f'{key} not in LRU Cache')
+        else:
+            node_reference = self.hashtable[key]
+            self.moveToFront(key)
+            return node_reference.value
+
+    def moveToFront(self, key):
+        node_reference = self.hashtable[key]
+        # check if its already the head
+        # we don't want to touch it then
+        if node_reference is self.head:
+            return
+        # check if its the tail
+        if node_reference is self.tail:
+            new_tail = self.tail.prev
+            new_tail.next = None
+            self.tail = new_tail
+            node_reference.next = self.head
+            self.head.prev = node_reference
+            node_reference.prev = None
+            self.head = node_reference
+        else:
+            # pull it out
+            node_reference.prev.next = node_reference.next
+            node_reference.next = self.head
+            self.head.prev = node_reference
+            self.head = node_reference
+            node_reference.prev = None
+
+    def checkCapacity(self):
+        if self.capacity > self.maxCapacity:
+            new_tail = self.tail.prev
+            new_tail.next = None
+            self.capacity -= 1
+            return
+
+
+cache = LRUCache()
+cache.put('a', 3)
+cache.put('b', 10)
+cache.put('c', 3)
+cache.put('d', 1)
+cache.put('a', 1)
+cache.put('a', 2)
+cache.put('d', -10)
+cache.put('e', 9)
+
+print(cache.get('d'))

Hashtables/maximumCollinearPoints.py

@@ -0,0 +1,137 @@
+"""
+Maximum Collinear Points
+Given an array of distinct points in 2D space, find the maximum number of points that lie on the same line.
+
+Example #1:
+Input: [[0, 1], [1, 0], [2, 0]]
+
+         -
+         |
+         -
+         |
+         🔵
+         |
+|--|--|--|--🔵--🔵--|
+         |
+         -
+         |
+         -
+         |
+         -
+
+Output: 2
+Explanation: Choose any two points; they lie on the same line. Since the three points aren’t collinear, it’s clear that we can’t do any better.
+
+Example #2:
+Input: [[0, 1], [1, 0], [2, 0], [10, 0]]
+
+         -
+         |
+         -
+         |
+         🔵
+         |
+|--|--|--|--🔵--🔵--|--|--|--|--|--|--|--🔵--|
+         |
+         -
+         |
+         -
+         |
+         -
+
+Output: 3
+Explanation: Choose the points (1, 0), (2, 0), and (10, 0). These three points are collinear, and this is an optimal solution.
+"""
+
+
+class Solution:
+    def maximumCollinearPoints(self, points):
+        """
+        Interface
+        ----
+        :type points: list of list of int
+        :rtype: int
+
+        Approach
+        ----
+        Slope Approach
+        1. A brute force solution is to simply traverse all possible pairs of points and count the number of points that are on the
+        line determined by the pair of points we are iterating over.
+
+        2. This gives a cubic-time solution. However, we can reduce our time complexity by utilizing hashing.
+
+        3. Instead of traversing all possible pairs of points, we traverse all possible lines.
+
+        4. For each point in our array, we can compute the slope of the line generated by this point and every other point in our array.
+
+        5.Any two points that have the same slope relative to the point that we are iterating over will lie on the same line.
+
+        6. Thus, we can keep a count of the number of points whose slope relative to the point that we are iterating over is equal to some value,
+        and we can take the maximum over all such counters to determine our final answer.
+
+        7. To keep such a counter, one approach is to a hashtable that maps a floating-point number (representing the slope of each line) to an integer (representing
+        a count of the number of points whose slope relative to the current point equals that value).
+
+        8. However, it is usually not a good idea to use floating-point numbers as keys when hashing due to potential precision issues.
+        Thus, we instead use strings of the form "dy/dx" (where "dy" and "dx" are the change in y and x-values respectively) as our keys,
+        and these keys map to the number of times that this slope appears relative to the point being iterated over.
+
+        9. We also ensure that our fraction is in reduced form by dividing both "dy" and "dx" by their greatest common divisor so that we do
+        not end up keeping multiple counters for the same slope value.
+
+        Complexity
+        ----
+        Time :
+        Space : O(N)
+        """
+
+        # Shortcut: If we have two or less points, we can take all of them.
+        if len(points) <= 2:
+            return len(points)
+
+        answer = 0
+        for i in range(0, len(points)):
+
+            # Hash Table for storing the slopes
+            # In the form of a string
+            slope_counter = {}
+
+            # Calulate the slope for each pair
+            for j in range(i + 1, len(points)):
+                dy = points[j][1] - points[i][1]
+                dx = points[j][0] - points[i][0]
+
+                # Gcd is calculated for reducing fractions
+                gcd = self.get_gcd(dy, dx)
+
+                # Make sure our fractions are fully reduced.
+                dy //= gcd
+                dx //= gcd
+
+                # Convert slopes to strings; avoid dealing with floating-point precision.
+                signature = f'{dy}/{dx}'
+                if signature in slope_counter:
+                    slope_counter[signature] += 1
+                else:
+                    slope_counter[signature] = 1
+            # Update the maximum answer
+            for key, pointsCountForSlope in slope_counter.items():
+                # Add 1 to include the point we iterated off of.
+                answer = max(answer, pointsCountForSlope + 1)
+
+        return answer
+
+    # Helper Function to calculate GCD
+    # gcd(0,n) = gcd(n,0) = n
+    def get_gcd(self, a, b):
+        if a == 0:
+            return b
+        if b == 0:
+            return a
+        r = a % b
+
+        return self.get_gcd(b, r) if r != 0 else b
+
+
+i = [[0, 1], [1, 0], [2, 0], [10, 0]]
+print(Solution().maximumCollinearPoints(i))