Adding Non commutative version and Doubly Linked List template

.gitignore

@@ -16,4 +16,5 @@ build/
 pythonenv3.8/
 .vscode/
 # Ignoring the virtual Environment when using GitHub Codespaces
-.venv/
+.venv/
+.DS_Store

algorithms/backtrack/__init__.py

@@ -1,5 +1,5 @@
 from .add_operators import *
-from .anagram import *
+from ..strings.anagram import *
 from .array_sum_combinations import *
 from .combination_sum import *
 from .factor_combinations import *

algorithms/graph/topological_sorting.py

@@ -0,0 +1,32 @@
+def findOrder(self, numCourses, prerequisites):
+    def topologicalsort(g):
+        indegrees = {node : 0 for node in g}
+
+        for node in g:
+            for neighbor in g[node]:
+                indegrees[neighbor] += 1
+
+        q = []
+        for node in g:
+            if indegrees[node] == 0:
+                q.append(node)
+
+        order = []
+        while q:
+            node = q.pop()
+            order.append(node)
+            for neighbor in g[node]:
+                indegrees[neighbor] -= 1
+                if indegrees[neighbor] == 0:
+                    q.append(neighbor)
+
+        return order
+
+    g = {i : [] for i in range(numCourses)}
+    for p in prerequisites:
+        src,dest = p
+        g[src].append(dest)
+
+    order = topologicalsort(g)
+
+    return reversed(order) if len(order) == numCourses else []

algorithms/heap/binary_heap.py

@@ -1,4 +1,4 @@
-r"""
+"""
 Binary Heap. A min heap is a complete binary tree where each node is smaller than
 its children. The root, therefore, is the minimum element in the tree. The min
 heap uses an array to represent the data and operation. For example a min heap:
@@ -29,39 +29,7 @@
 55 90 87             55  90                 55  90
 
 """
-from abc import ABCMeta, abstractmethod
-
-
-class AbstractHeap(metaclass=ABCMeta):
-    """Abstract Class for Binary Heap."""
-
-    def __init__(self):
-        """Pass."""
-
-    @abstractmethod
-    def perc_up(self, i):
-        """Pass."""
-
-    @abstractmethod
-    def insert(self, val):
-        """Pass."""
-
-    @abstractmethod
-    def perc_down(self, i):
-        """Pass."""
-
-    @abstractmethod
-    def min_child(self, i):
-        """Pass."""
-
-    @abstractmethod
-    def remove_min(self):
-        """Pass."""
-
-
-class BinaryHeap(AbstractHeap):
-    """Binary Heap Class"""
-
+class BinaryHeap():
     def __init__(self):
         self.current_size = 0
         self.heap = [(0)]
@@ -73,23 +41,22 @@ def perc_up(self, i):
                 self.heap[i], self.heap[i//2] = self.heap[i//2], self.heap[i]
             i = i // 2
 
-    def insert(self, val):
-        """
+    """
         Method insert always start by inserting the element at the bottom.
         It inserts rightmost spot so as to maintain the complete tree property.
         Then, it fixes the tree by swapping the new element with its parent,
         until it finds an appropriate spot for the element. It essentially
         perc_up the minimum element
         Complexity: O(logN)
-        """
+    """
+    def insert(self, val):
         self.heap.append(val)
         self.current_size = self.current_size + 1
         self.perc_up(self.current_size)
 
-        """
-        Method min_child returns the index of smaller of 2 children of parent at index i
-        """
-
+    """
+    Method min_child returns the index of smaller of 2 children of parent at index i
+    """
     def min_child(self, i):
         if 2 * i + 1 > self.current_size:  # No right child
             return 2 * i
@@ -98,25 +65,25 @@ def min_child(self, i):
         return 2 * i
 
     def perc_down(self, i):
-        while 2 * i < self.current_size:
+        while 2 * i <= self.current_size:
             min_child = self.min_child(i)
             if self.heap[min_child] < self.heap[i]:
                 # Swap min child with parent
                 self.heap[min_child], self.heap[i] = self.heap[i], self.heap[min_child]
             i = min_child
+
     """
         Remove Min method removes the minimum element and swap it with the last
         element in the heap( the bottommost, rightmost element). Then, it
         perc_down this element, swapping it with one of its children until the
         min heap property is restored
         Complexity: O(logN)
     """
-
     def remove_min(self):
-        ret = self.heap[1]      # the smallest value at beginning
+        popped = self.heap[1]      # the smallest value at beginning
         # Replace it by the last value
         self.heap[1] = self.heap[self.current_size]
         self.current_size = self.current_size - 1
         self.heap.pop()
         self.perc_down(1)
-        return ret
+        return popped

algorithms/linkedlist/DoublyLinkedList.py

@@ -0,0 +1,52 @@
+class DoublyLinkedListNode(object):
+    def __init__(self, value):
+        self.value = value
+        self.next = None
+        self.prev = None
+
+class Doubly():
+    def _add_node(self, node):
+        """
+        Always add the new node right after head.
+        """
+        node.prev = self.head
+        node.next = self.head.next
+
+        self.head.next.prev = node
+        self.head.next = node
+
+    def _remove_node(self, node):
+        """
+        Remove an existing node from the linked list.
+        """
+        prev = node.prev
+        new = node.next
+
+        prev.next = new
+        new.prev = prev
+
+    def _move_to_head(self, node):
+        """
+        Move certain node in between to the head.
+        """
+        self._remove_node(node)
+        self._add_node(node)
+
+    def _pop_tail(self):
+        """
+        Pop the current tail.
+        """
+        res = self.tail.prev
+        self._remove_node(res)
+        return res
+
+    def __init__(self, capacity):
+        """
+        :type capacity: int
+        """
+        self.size = 0
+        self.capacity = capacity
+        self.head, self.tail = DoublyLinkedListNode(), DoublyLinkedListNode()
+
+        self.head.next = self.tail
+        self.tail.prev = self.head

algorithms/maths/find_prime_factors.py

@@ -0,0 +1,21 @@
+# Gives the shortest prime factor for a number
+# Assign N the biggest num and then call getPrimeFactorization for each num
+import math
+N = 1000001
+spf = [-1] * N
+def shortesPrimeFactorForEachNum():
+    global spf
+    for i in range(4, N, 1):
+        spf[i] = 2
+    for i in range(3, math.ceil(N ** 0.5)):
+        if spf[i] == -1:
+            for j in range(i ** 2, N, i):
+                if spf[j] == -1:
+                    spf[j] = i
+shortesPrimeFactorForEachNum()
+def getPrimeFactorization(x):
+    ret = list()
+    while (x != 1):
+        ret.append(spf[x])
+        x = x // spf[x]
+    return ret

algorithms/maths/prime_factorization.py

@@ -0,0 +1,38 @@
+from math import *
+N = 10000001
+# stores smallest prime factor for
+# every number
+spf = [0 for i in range(N)]
+# Calculating SPF (Smallest Prime Factor)
+# for every number till N.
+# Time Complexity : O(nloglogn)
+def sieve():
+    spf[1] = 1
+    for i in range(2, N):
+        # marking smallest prime factor
+        # for every number to be itself.
+        spf[i] = i
+    # separately marking spf for
+    # every even number as 2
+    for i in range(4, N, 2):
+        spf[i] = 2
+    for i in range(3, ceil(N ** 0.5)):
+        # checking if i is prime
+        if (spf[i] == i):
+            # marking SPF for all numbers
+            # divisible by i
+            for j in range(i * i, N, i):
+                # marking spf[j] if it is
+                # not previously marked
+                if (spf[j] == j):
+                    spf[j] = i
+# A O(log n) function returning prime
+# factorization by dividing by smallest
+# prime factor at every step
+def getPrimeFactorization(x):
+    ret = list()
+    while (x != 1):
+        ret.append(spf[x])
+        x = x // spf[x]
+    return ret
+sieve()

algorithms/maths/prime_factorization_10^9.py

@@ -0,0 +1,22 @@
+''' Uses the Idea that all prime numbers are odd and for numbers like 9 we can just 
+start from 3 and continously divide to eliminate 9 '''
+
+import math
+def primeFactors(n):
+    res = []
+    # Print the number of two's that divide n
+    while n & 1 ^ 1:
+        res.append(2)
+        n >>= 1
+    # n must be odd at this point
+    # so a skip of 2 ( i = i + 2) can be used
+    for i in range(3, int(math.sqrt(n)) + 1, 2):
+        # while i divides n , print i and divide n
+        while n % i == 0:
+            res.append(i)
+            n //= i
+    # Condition if n is a prime
+    # number greater than 2
+    if n > 2:
+        res.append(n)
+    return res

algorithms/maths/primes_sieve_of_eratosthenes.py

@@ -31,14 +31,13 @@ def get_primes(n):
     if n <= 0:
         raise ValueError("'n' must be a positive integer.")
     # If x is even, exclude x from list (-1):
-    sieve_size = (n // 2 - 1) if n % 2 == 0 else (n // 2)
+    sieve_size = (n >> 1) if n & 1 else ((n >> 1) - 1)
     sieve = [True for _ in range(sieve_size)]   # Sieve
-    primes = []      # List of Primes
-    if n >= 2:
-        primes.append(2)      # 2 is prime by default
+    primes = []
+    if n >= 2: primes.append(2)      # 2 is prime by default
     for i in range(sieve_size):
         if sieve[i]:
-            value_at_i = i*2 + 3
+            value_at_i = i << 1 + 3
             primes.append(value_at_i)
             for j in range(i, sieve_size, value_at_i):
                 sieve[j] = False

algorithms/shivsQuickBucket/2dDP_Space_optimization.py

@@ -0,0 +1,36 @@
+from functools import cache
+
+# 2D DP
+class Solution:
+    def maxProfit(self, prices, fee: int) -> int:
+        @cache
+        def recursion(prev, curri):
+            if not curri < len(prices): return 0
+
+            profit = 0
+            if not prev:
+                profit = max(recursion(prev, curri + 1), recursion(prices[curri], curri + 1))
+            elif prices[curri] > prev:
+                profit = max((prices[curri] - prev - fee) + recursion(0, curri + 1), recursion(prev, curri + 1))
+            else:
+                profit = recursion(prev, curri + 1)
+            return profit
+        return recursion(0, 0)
+
+# Converted to 2D DP space optimized
+class Solution:
+    def maxProfit(self, prices, fee: int) -> int:
+        @cache
+        def recursion(curri, b):
+            if curri == len(prices): return 0
+
+            if b:
+                buy = recursion(curri + 1, 0) - prices[curri] - fee
+                notBuy = recursion(curri + 1, 1)
+                return max(buy, notBuy)
+
+            sell = recursion(curri + 1, 1) + prices[curri]
+            notSell = recursion(curri + 1, 0)
+            return max(sell, notSell)
+
+        return recursion(0, 1)