Merge branch 'TheAlgorithms:master' into master

Author: Ramy-Badr-Ahmed

.pre-commit-config.yaml

@@ -16,20 +16,20 @@ repos:
       - id: auto-walrus
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.9.3
+    rev: v0.11.2
     hooks:
       - id: ruff
       - id: ruff-format
 
   - repo: https://github.com/codespell-project/codespell
-    rev: v2.4.0
+    rev: v2.4.1
     hooks:
       - id: codespell
         additional_dependencies:
           - tomli
 
   - repo: https://github.com/tox-dev/pyproject-fmt
-    rev: "v2.5.0"
+    rev: "v2.5.1"
     hooks:
       - id: pyproject-fmt
 
@@ -42,12 +42,12 @@ repos:
         pass_filenames: false
 
   - repo: https://github.com/abravalheri/validate-pyproject
-    rev: v0.23
+    rev: v0.24.1
     hooks:
       - id: validate-pyproject
 
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.14.1
+    rev: v1.15.0
     hooks:
       - id: mypy
         args:

DIRECTORY.md

@@ -275,20 +275,21 @@
     * [Singly Linked List](data_structures/linked_list/singly_linked_list.py)
     * [Skip List](data_structures/linked_list/skip_list.py)
     * [Swap Nodes](data_structures/linked_list/swap_nodes.py)
-  * Queue
-    * [Circular Queue](data_structures/queue/circular_queue.py)
-    * [Circular Queue Linked List](data_structures/queue/circular_queue_linked_list.py)
-    * [Double Ended Queue](data_structures/queue/double_ended_queue.py)
-    * [Linked Queue](data_structures/queue/linked_queue.py)
-    * [Priority Queue Using List](data_structures/queue/priority_queue_using_list.py)
-    * [Queue By List](data_structures/queue/queue_by_list.py)
-    * [Queue By Two Stacks](data_structures/queue/queue_by_two_stacks.py)
-    * [Queue On Pseudo Stack](data_structures/queue/queue_on_pseudo_stack.py)
+  * Queues
+    * [Circular Queue](data_structures/queues/circular_queue.py)
+    * [Circular Queue Linked List](data_structures/queues/circular_queue_linked_list.py)
+    * [Double Ended Queue](data_structures/queues/double_ended_queue.py)
+    * [Linked Queue](data_structures/queues/linked_queue.py)
+    * [Priority Queue Using List](data_structures/queues/priority_queue_using_list.py)
+    * [Queue By List](data_structures/queues/queue_by_list.py)
+    * [Queue By Two Stacks](data_structures/queues/queue_by_two_stacks.py)
+    * [Queue On Pseudo Stack](data_structures/queues/queue_on_pseudo_stack.py)
   * Stacks
     * [Balanced Parentheses](data_structures/stacks/balanced_parentheses.py)
     * [Dijkstras Two Stack Algorithm](data_structures/stacks/dijkstras_two_stack_algorithm.py)
     * [Infix To Postfix Conversion](data_structures/stacks/infix_to_postfix_conversion.py)
     * [Infix To Prefix Conversion](data_structures/stacks/infix_to_prefix_conversion.py)
+    * [Largest Rectangle Histogram](data_structures/stacks/largest_rectangle_histogram.py)
     * [Lexicographical Numbers](data_structures/stacks/lexicographical_numbers.py)
     * [Next Greater Element](data_structures/stacks/next_greater_element.py)
     * [Postfix Evaluation](data_structures/stacks/postfix_evaluation.py)
@@ -395,6 +396,7 @@
   * [Minimum Tickets Cost](dynamic_programming/minimum_tickets_cost.py)
   * [Optimal Binary Search Tree](dynamic_programming/optimal_binary_search_tree.py)
   * [Palindrome Partitioning](dynamic_programming/palindrome_partitioning.py)
+  * [Range Sum Query](dynamic_programming/range_sum_query.py)
   * [Regex Match](dynamic_programming/regex_match.py)
   * [Rod Cutting](dynamic_programming/rod_cutting.py)
   * [Smith Waterman](dynamic_programming/smith_waterman.py)
@@ -608,6 +610,7 @@
   * [Mfcc](machine_learning/mfcc.py)
   * [Multilayer Perceptron Classifier](machine_learning/multilayer_perceptron_classifier.py)
   * [Polynomial Regression](machine_learning/polynomial_regression.py)
+  * [Principle Component Analysis](machine_learning/principle_component_analysis.py)
   * [Scoring Functions](machine_learning/scoring_functions.py)
   * [Self Organizing Map](machine_learning/self_organizing_map.py)
   * [Sequential Minimum Optimization](machine_learning/sequential_minimum_optimization.py)

backtracking/n_queens.py

@@ -27,21 +27,28 @@ def is_safe(board: list[list[int]], row: int, column: int) -> bool:
 
     >>> is_safe([[0, 0, 0], [0, 0, 0], [0, 0, 0]], 1, 1)
     True
+    >>> is_safe([[0, 1, 0], [0, 0, 0], [0, 0, 0]], 1, 1)
+    False
     >>> is_safe([[1, 0, 0], [0, 0, 0], [0, 0, 0]], 1, 1)
     False
+    >>> is_safe([[0, 0, 1], [0, 0, 0], [0, 0, 0]], 1, 1)
+    False
     """
 
     n = len(board)  # Size of the board
 
-    # Check if there is any queen in the same row, column,
-    # left upper diagonal, and right upper diagonal
+    # Check if there is any queen in the same upper column,
+    # left upper diagonal and right upper diagonal
     return (
-        all(board[i][j] != 1 for i, j in zip(range(row, -1, -1), range(column, n)))
+        all(board[i][j] != 1 for i, j in zip(range(row), [column] * row))
+        and all(
+            board[i][j] != 1
+            for i, j in zip(range(row - 1, -1, -1), range(column - 1, -1, -1))
+        )
         and all(
-            board[i][j] != 1 for i, j in zip(range(row, -1, -1), range(column, -1, -1))
+            board[i][j] != 1
+            for i, j in zip(range(row - 1, -1, -1), range(column + 1, n))
         )
-        and all(board[i][j] != 1 for i, j in zip(range(row, n), range(column, n)))
-        and all(board[i][j] != 1 for i, j in zip(range(row, n), range(column, -1, -1)))
     )
 
 

conversions/prefix_conversions_string.py

@@ -53,7 +53,7 @@ class SIUnit(Enum):
     yocto = -24
 
     @classmethod
-    def get_positive(cls: type[T]) -> dict:
+    def get_positive(cls) -> dict:
         """
         Returns a dictionary with only the elements of this enum
         that has a positive value
@@ -68,7 +68,7 @@ def get_positive(cls: type[T]) -> dict:
         return {unit.name: unit.value for unit in cls if unit.value > 0}
 
     @classmethod
-    def get_negative(cls: type[T]) -> dict:
+    def get_negative(cls) -> dict:
         """
         Returns a dictionary with only the elements of this enum
         that has a negative value

data_structures/arrays/prefix_sum.py

@@ -30,11 +30,29 @@ def get_sum(self, start: int, end: int) -> int:
         5
         >>> PrefixSum([1,2,3]).get_sum(2, 2)
         3
+        >>> PrefixSum([]).get_sum(0, 0)
+        Traceback (most recent call last):
+        ...
+        ValueError: The array is empty.
+        >>> PrefixSum([1,2,3]).get_sum(-1, 2)
+        Traceback (most recent call last):
+        ...
+        ValueError: Invalid range specified.
         >>> PrefixSum([1,2,3]).get_sum(2, 3)
         Traceback (most recent call last):
         ...
-        IndexError: list index out of range
+        ValueError: Invalid range specified.
+        >>> PrefixSum([1,2,3]).get_sum(2, 1)
+        Traceback (most recent call last):
+        ...
+        ValueError: Invalid range specified.
         """
+        if not self.prefix_sum:
+            raise ValueError("The array is empty.")
+
+        if start < 0 or end >= len(self.prefix_sum) or start > end:
+            raise ValueError("Invalid range specified.")
+
         if start == 0:
             return self.prefix_sum[end]
 

data_structures/arrays/sudoku_solver.py

@@ -54,7 +54,7 @@ def parse_grid(grid):
     return False if a contradiction is detected.
     """
     ## To start, every square can be any digit; then assign values from the grid.
-    values = {s: digits for s in squares}
+    values = dict.fromkeys(squares, digits)
     for s, d in grid_values(grid).items():
         if d in digits and not assign(values, s, d):
             return False  ## (Fail if we can't assign d to square s.)
@@ -203,7 +203,7 @@ def random_puzzle(assignments=17):
     Note the resulting puzzle is not guaranteed to be solvable, but empirically
     about 99.8% of them are solvable. Some have multiple solutions.
     """
-    values = {s: digits for s in squares}
+    values = dict.fromkeys(squares, digits)
     for s in shuffled(squares):
         if not assign(values, s, random.choice(values[s])):
             break

data_structures/linked_list/doubly_linked_list_two.py

@@ -9,25 +9,19 @@
      Delete operation is more efficient
 """
 
+from dataclasses import dataclass
+from typing import Self
 
+
+@dataclass
 class Node:
-    def __init__(self, data: int, previous=None, next_node=None):
-        self.data = data
-        self.previous = previous
-        self.next = next_node
+    data: int
+    previous: Self | None = None
+    next: Self | None = None
 
     def __str__(self) -> str:
         return f"{self.data}"
 
-    def get_data(self) -> int:
-        return self.data
-
-    def get_next(self):
-        return self.next
-
-    def get_previous(self):
-        return self.previous
-
 
 class LinkedListIterator:
     def __init__(self, head):
@@ -40,43 +34,43 @@ def __next__(self):
         if not self.current:
             raise StopIteration
         else:
-            value = self.current.get_data()
-            self.current = self.current.get_next()
+            value = self.current.data
+            self.current = self.current.next
             return value
 
 
+@dataclass
 class LinkedList:
-    def __init__(self):
-        self.head = None  # First node in list
-        self.tail = None  # Last node in list
+    head: Node | None = None  # First node in list
+    tail: Node | None = None  # Last node in list
 
     def __str__(self):
         current = self.head
         nodes = []
         while current is not None:
-            nodes.append(current.get_data())
-            current = current.get_next()
+            nodes.append(current.data)
+            current = current.next
         return " ".join(str(node) for node in nodes)
 
     def __contains__(self, value: int):
         current = self.head
         while current:
-            if current.get_data() == value:
+            if current.data == value:
                 return True
-            current = current.get_next()
+            current = current.next
         return False
 
     def __iter__(self):
         return LinkedListIterator(self.head)
 
     def get_head_data(self):
         if self.head:
-            return self.head.get_data()
+            return self.head.data
         return None
 
     def get_tail_data(self):
         if self.tail:
-            return self.tail.get_data()
+            return self.tail.data
         return None
 
     def set_head(self, node: Node) -> None:
@@ -87,8 +81,9 @@ def set_head(self, node: Node) -> None:
             self.insert_before_node(self.head, node)
 
     def set_tail(self, node: Node) -> None:
-        if self.head is None:
-            self.set_head(node)
+        if self.tail is None:
+            self.head = node
+            self.tail = node
         else:
             self.insert_after_node(self.tail, node)
 
@@ -103,7 +98,7 @@ def insert_before_node(self, node: Node, node_to_insert: Node) -> None:
         node_to_insert.next = node
         node_to_insert.previous = node.previous
 
-        if node.get_previous() is None:
+        if node.previous is None:
             self.head = node_to_insert
         else:
             node.previous.next = node_to_insert
@@ -114,7 +109,7 @@ def insert_after_node(self, node: Node, node_to_insert: Node) -> None:
         node_to_insert.previous = node
         node_to_insert.next = node.next
 
-        if node.get_next() is None:
+        if node.next is None:
             self.tail = node_to_insert
         else:
             node.next.previous = node_to_insert
@@ -131,32 +126,32 @@ def insert_at_position(self, position: int, value: int) -> None:
                 return
             current_position += 1
             node = node.next
-        self.insert_after_node(self.tail, new_node)
+        self.set_tail(new_node)
 
     def get_node(self, item: int) -> Node:
         node = self.head
         while node:
-            if node.get_data() == item:
+            if node.data == item:
                 return node
-            node = node.get_next()
+            node = node.next
         raise Exception("Node not found")
 
     def delete_value(self, value):
         if (node := self.get_node(value)) is not None:
             if node == self.head:
-                self.head = self.head.get_next()
+                self.head = self.head.next
 
             if node == self.tail:
-                self.tail = self.tail.get_previous()
+                self.tail = self.tail.previous
 
             self.remove_node_pointers(node)
 
     @staticmethod
     def remove_node_pointers(node: Node) -> None:
-        if node.get_next():
+        if node.next:
             node.next.previous = node.previous
 
-        if node.get_previous():
+        if node.previous:
             node.previous.next = node.next
 
         node.next = None
@@ -241,6 +236,22 @@ def create_linked_list() -> None:
     7
     8
     9
+    >>> linked_list = LinkedList()
+    >>> linked_list.insert_at_position(position=1, value=10)
+    >>> str(linked_list)
+    '10'
+    >>> linked_list.insert_at_position(position=2, value=20)
+    >>> str(linked_list)
+    '10 20'
+    >>> linked_list.insert_at_position(position=1, value=30)
+    >>> str(linked_list)
+    '30 10 20'
+    >>> linked_list.insert_at_position(position=3, value=40)
+    >>> str(linked_list)
+    '30 10 40 20'
+    >>> linked_list.insert_at_position(position=5, value=50)
+    >>> str(linked_list)
+    '30 10 40 20 50'
     """
 
 

data_structures/linked_list/from_sequence.py

@@ -1,4 +1,4 @@
-# Recursive Prorgam to create a Linked List from a sequence and
+# Recursive Program to create a Linked List from a sequence and
 # print a string representation of it.