Merge branch 'TheAlgorithms:master' into master

Author: haxkd

data_structures/queue/double_ended_queue.py

@@ -242,31 +242,45 @@ def pop(self) -> Any:
         Removes the last element of the deque and returns it.
         Time complexity: O(1)
         @returns topop.val: the value of the node to pop.
-        >>> our_deque = Deque([1, 2, 3, 15182])
-        >>> our_popped = our_deque.pop()
-        >>> our_popped
+        >>> our_deque1 = Deque([1])
+        >>> our_popped1 = our_deque1.pop()
+        >>> our_popped1
+        1
+        >>> our_deque1
+        []
+
+        >>> our_deque2 = Deque([1, 2, 3, 15182])
+        >>> our_popped2 = our_deque2.pop()
+        >>> our_popped2
         15182
-        >>> our_deque
+        >>> our_deque2
         [1, 2, 3]
+
         >>> from collections import deque
         >>> deque_collections = deque([1, 2, 3, 15182])
         >>> collections_popped = deque_collections.pop()
         >>> collections_popped
         15182
         >>> deque_collections
         deque([1, 2, 3])
-        >>> list(our_deque) == list(deque_collections)
+        >>> list(our_deque2) == list(deque_collections)
         True
-        >>> our_popped == collections_popped
+        >>> our_popped2 == collections_popped
         True
         """
         # make sure the deque has elements to pop
         assert not self.is_empty(), "Deque is empty."
 
         topop = self._back
-        self._back = self._back.prev_node  # set new back
-        # drop the last node - python will deallocate memory automatically
-        self._back.next_node = None
+        # if only one element in the queue: point the front and back to None
+        # else remove one element from back
+        if self._front == self._back:
+            self._front = None
+            self._back = None
+        else:
+            self._back = self._back.prev_node  # set new back
+            # drop the last node, python will deallocate memory automatically
+            self._back.next_node = None
 
         self._len -= 1
 
@@ -277,11 +291,17 @@ def popleft(self) -> Any:
         Removes the first element of the deque and returns it.
         Time complexity: O(1)
         @returns topop.val: the value of the node to pop.
-        >>> our_deque = Deque([15182, 1, 2, 3])
-        >>> our_popped = our_deque.popleft()
-        >>> our_popped
+        >>> our_deque1 = Deque([1])
+        >>> our_popped1 = our_deque1.pop()
+        >>> our_popped1
+        1
+        >>> our_deque1
+        []
+        >>> our_deque2 = Deque([15182, 1, 2, 3])
+        >>> our_popped2 = our_deque2.popleft()
+        >>> our_popped2
         15182
-        >>> our_deque
+        >>> our_deque2
         [1, 2, 3]
         >>> from collections import deque
         >>> deque_collections = deque([15182, 1, 2, 3])
@@ -290,17 +310,23 @@ def popleft(self) -> Any:
         15182
         >>> deque_collections
         deque([1, 2, 3])
-        >>> list(our_deque) == list(deque_collections)
+        >>> list(our_deque2) == list(deque_collections)
         True
-        >>> our_popped == collections_popped
+        >>> our_popped2 == collections_popped
         True
         """
         # make sure the deque has elements to pop
         assert not self.is_empty(), "Deque is empty."
 
         topop = self._front
-        self._front = self._front.next_node  # set new front and drop the first node
-        self._front.prev_node = None
+        # if only one element in the queue: point the front and back to None
+        # else remove one element from front
+        if self._front == self._back:
+            self._front = None
+            self._back = None
+        else:
+            self._front = self._front.next_node  # set new front and drop the first node
+            self._front.prev_node = None
 
         self._len -= 1
 
@@ -432,3 +458,5 @@ def __repr__(self) -> str:
     import doctest
 
     doctest.testmod()
+    dq = Deque([3])
+    dq.pop()

dynamic_programming/largest_divisible_subset.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+
+def largest_divisible_subset(items: list[int]) -> list[int]:
+    """
+    Algorithm to find the biggest subset in the given array such that for any 2 elements
+    x and y in the subset, either x divides y or y divides x.
+    >>> largest_divisible_subset([1, 16, 7, 8, 4])
+    [16, 8, 4, 1]
+    >>> largest_divisible_subset([1, 2, 3])
+    [2, 1]
+    >>> largest_divisible_subset([-1, -2, -3])
+    [-3]
+    >>> largest_divisible_subset([1, 2, 4, 8])
+    [8, 4, 2, 1]
+    >>> largest_divisible_subset((1, 2, 4, 8))
+    [8, 4, 2, 1]
+    >>> largest_divisible_subset([1, 1, 1])
+    [1, 1, 1]
+    >>> largest_divisible_subset([0, 0, 0])
+    [0, 0, 0]
+    >>> largest_divisible_subset([-1, -1, -1])
+    [-1, -1, -1]
+    >>> largest_divisible_subset([])
+    []
+    """
+    # Sort the array in ascending order as the sequence does not matter we only have to
+    # pick up a subset.
+    items = sorted(items)
+
+    number_of_items = len(items)
+
+    # Initialize memo with 1s and hash with increasing numbers
+    memo = [1] * number_of_items
+    hash_array = list(range(number_of_items))
+
+    # Iterate through the array
+    for i, item in enumerate(items):
+        for prev_index in range(i):
+            if ((items[prev_index] != 0 and item % items[prev_index]) == 0) and (
+                (1 + memo[prev_index]) > memo[i]
+            ):
+                memo[i] = 1 + memo[prev_index]
+                hash_array[i] = prev_index
+
+    ans = -1
+    last_index = -1
+
+    # Find the maximum length and its corresponding index
+    for i, memo_item in enumerate(memo):
+        if memo_item > ans:
+            ans = memo_item
+            last_index = i
+
+    # Reconstruct the divisible subset
+    if last_index == -1:
+        return []
+    result = [items[last_index]]
+    while hash_array[last_index] != last_index:
+        last_index = hash_array[last_index]
+        result.append(items[last_index])
+
+    return result
+
+
+if __name__ == "__main__":
+    from doctest import testmod
+
+    testmod()
+
+    items = [1, 16, 7, 8, 4]
+    print(
+        f"The longest divisible subset of {items} is {largest_divisible_subset(items)}."
+    )

graphs/check_bipartite_graph_dfs.py

@@ -1,34 +1,55 @@
-# Check whether Graph is Bipartite or Not using DFS
+from collections import defaultdict
 
 
-# A Bipartite Graph is a graph whose vertices can be divided into two independent sets,
-# U and V such that every edge (u, v) either connects a vertex from U to V or a vertex
-# from V to U. In other words, for every edge (u, v), either u belongs to U and v to V,
-# or u belongs to V and v to U. We can also say that there is no edge that connects
-# vertices of same set.
-def check_bipartite_dfs(graph):
-    visited = [False] * len(graph)
-    color = [-1] * len(graph)
+def is_bipartite(graph: defaultdict[int, list[int]]) -> bool:
+    """
+    Check whether a graph is Bipartite or not using Depth-First Search (DFS).
 
-    def dfs(v, c):
-        visited[v] = True
-        color[v] = c
-        for u in graph[v]:
-            if not visited[u]:
-                dfs(u, 1 - c)
+    A Bipartite Graph is a graph whose vertices can be divided into two independent
+    sets, U and V such that every edge (u, v) either connects a vertex from
+    U to V or a vertex from V to U. In other words, for every edge (u, v),
+    either u belongs to U and v to V, or u belongs to V and v to U. There is
+    no edge that connects vertices of the same set.
 
-    for i in range(len(graph)):
-        if not visited[i]:
-            dfs(i, 0)
+    Args:
+        graph: An adjacency list representing the graph.
 
-    for i in range(len(graph)):
-        for j in graph[i]:
-            if color[i] == color[j]:
-                return False
+    Returns:
+        True if there's no edge that connects vertices of the same set, False otherwise.
 
-    return True
+    Examples:
+        >>> is_bipartite(
+        ...     defaultdict(list, {0: [1, 2], 1: [0, 3], 2: [0, 4], 3: [1], 4: [2]})
+        ... )
+        False
+        >>> is_bipartite(defaultdict(list, {0: [1, 2], 1: [0, 2], 2: [0, 1]}))
+        True
+    """
 
+    def depth_first_search(node: int, color: int) -> bool:
+        visited[node] = color
+        return any(
+            visited[neighbour] == color
+            or (
+                visited[neighbour] == -1
+                and not depth_first_search(neighbour, 1 - color)
+            )
+            for neighbour in graph[node]
+        )
 
-# Adjacency list of graph
-graph = {0: [1, 3], 1: [0, 2], 2: [1, 3], 3: [0, 2], 4: []}
-print(check_bipartite_dfs(graph))
+    visited: defaultdict[int, int] = defaultdict(lambda: -1)
+
+    return all(
+        not (visited[node] == -1 and not depth_first_search(node, 0)) for node in graph
+    )
+
+
+if __name__ == "__main__":
+    import doctest
+
+    result = doctest.testmod()
+
+    if result.failed:
+        print(f"{result.failed} test(s) failed.")
+    else:
+        print("All tests passed!")

greedy_methods/gas_station.py

@@ -0,0 +1,97 @@
+"""
+Task:
+There are n gas stations along a circular route, where the amount of gas
+at the ith station is gas_quantities[i].
+
+You have a car with an unlimited gas tank and it costs costs[i] of gas
+to travel from the ith station to its next (i + 1)th station.
+You begin the journey with an empty tank at one of the gas stations.
+
+Given two integer arrays gas_quantities and costs, return the starting
+gas station's index if you can travel around the circuit once
+in the clockwise direction otherwise, return -1.
+If there exists a solution, it is guaranteed to be unique
+
+Reference: https://leetcode.com/problems/gas-station/description
+
+Implementation notes:
+First, check whether the total gas is enough to complete the journey. If not, return -1.
+However, if there is enough gas, it is guaranteed that there is a valid
+starting index to reach the end of the journey.
+Greedily calculate the net gain (gas_quantity - cost) at each station.
+If the net gain ever goes below 0 while iterating through the stations,
+start checking from the next station.
+
+"""
+from dataclasses import dataclass
+
+
+@dataclass
+class GasStation:
+    gas_quantity: int
+    cost: int
+
+
+def get_gas_stations(
+    gas_quantities: list[int], costs: list[int]
+) -> tuple[GasStation, ...]:
+    """
+    This function returns a tuple of gas stations.
+
+    Args:
+        gas_quantities: Amount of gas available at each station
+        costs: The cost of gas required to move from one station to the next
+
+    Returns:
+        A tuple of gas stations
+
+    >>> gas_stations = get_gas_stations([1, 2, 3, 4, 5], [3, 4, 5, 1, 2])
+    >>> len(gas_stations)
+    5
+    >>> gas_stations[0]
+    GasStation(gas_quantity=1, cost=3)
+    >>> gas_stations[-1]
+    GasStation(gas_quantity=5, cost=2)
+    """
+    return tuple(
+        GasStation(quantity, cost) for quantity, cost in zip(gas_quantities, costs)
+    )
+
+
+def can_complete_journey(gas_stations: tuple[GasStation, ...]) -> int:
+    """
+    This function returns the index from which to start the journey
+    in order to reach the end.
+
+    Args:
+        gas_quantities [list]: Amount of gas available at each station
+        cost [list]: The cost of gas required to move from one station to the next
+
+    Returns:
+        start [int]: start index needed to complete the journey
+
+    Examples:
+    >>> can_complete_journey(get_gas_stations([1, 2, 3, 4, 5], [3, 4, 5, 1, 2]))
+    3
+    >>> can_complete_journey(get_gas_stations([2, 3, 4], [3, 4, 3]))
+    -1
+    """
+    total_gas = sum(gas_station.gas_quantity for gas_station in gas_stations)
+    total_cost = sum(gas_station.cost for gas_station in gas_stations)
+    if total_gas < total_cost:
+        return -1
+
+    start = 0
+    net = 0
+    for i, gas_station in enumerate(gas_stations):
+        net += gas_station.gas_quantity - gas_station.cost
+        if net < 0:
+            start = i + 1
+            net = 0
+    return start
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()