[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Author: pre-commit-ci[bot]

Diff for: graphs/ant_colony_optimization_algorithms.py

@@ -13,18 +13,21 @@
     7: [6, 2],
 }
 
+
 def euclidean_distance(city1: list[int], city2: list[int]) -> float:
     """
     Calculate the Euclidean distance between two cities (points).
     """
     return math.sqrt((city1[0] - city2[0]) ** 2 + (city1[1] - city2[1]) ** 2)
 
+
 def initialize_pheromone_matrix(size: int) -> list[list[float]]:
     """
     Initialize the pheromone matrix with 1.0 values.
     """
     return [[1.0 for _ in range(size)] for _ in range(size)]
 
+
 def compute_distance_matrix(cities: dict[int, list[int]]) -> list[list[float]]:
     """
     Precompute the distance between all cities and store them in a matrix.
@@ -38,13 +41,14 @@ def compute_distance_matrix(cities: dict[int, list[int]]) -> list[list[float]]:
             dist_matrix[j][i] = dist
     return dist_matrix
 
+
 def select_next_city(
     current_city: int,
     unvisited: list[int],
     pheromone: list[list[float]],
     distances: list[list[float]],
     alpha: float,
-    beta: float
+    beta: float,
 ) -> int:
     """
     Select the next city to visit based on pheromone levels and distances.
@@ -62,14 +66,15 @@ def select_next_city(
     # Randomly select next city based on the probabilities
     return random.choices(unvisited, weights=probabilities)[0]
 
+
 def update_pheromones(
     pheromone: list[list[float]],
     ants_paths: list[list[int]],
     distances: list[list[float]],
     q: float,
     evaporation_rate: float,
     best_path: list[int],
-    best_distance: float
+    best_distance: float,
 ) -> tuple[list[list[float]], list[int], float]:
     """
     Update pheromone levels on the paths chosen by ants.
@@ -79,11 +84,13 @@ def update_pheromones(
     # Evaporate pheromones
     for i in range(size):
         for j in range(size):
-            pheromone[i][j] *= (1 - evaporation_rate)
+            pheromone[i][j] *= 1 - evaporation_rate
 
     # Update pheromones based on ants' paths
     for path in ants_paths:
-        total_distance = sum(distances[path[i]][path[i + 1]] for i in range(len(path) - 1))
+        total_distance = sum(
+            distances[path[i]][path[i + 1]] for i in range(len(path) - 1)
+        )
         pheromone_deposit = q / total_distance
 
         for i in range(len(path) - 1):
@@ -97,28 +104,29 @@ def update_pheromones(
 
     return pheromone, best_path, best_distance
 
+
 def ant_colony_optimization(
     cities: dict[int, list[int]],
     ants_num: int,
     iterations: int,
     alpha: float,
     beta: float,
     evaporation_rate: float,
-    q: float
+    q: float,
 ) -> tuple[list[int], float]:
     """
     Solve the TSP using Ant Colony Optimization (ACO).
     """
     cities_num = len(cities)
     if cities_num == 0:
-        return [], float('inf')  # No cities to visit
+        return [], float("inf")  # No cities to visit
 
     # Initialize pheromone and distance matrices
     pheromone = initialize_pheromone_matrix(cities_num)
     distances = compute_distance_matrix(cities)
 
     best_path = []
-    best_distance = float('inf')
+    best_distance = float("inf")
 
     for _ in range(iterations):
         all_paths = []
@@ -129,7 +137,9 @@ def ant_colony_optimization(
             # Construct path for the ant
             current_city = 0
             while unvisited:
-                next_city = select_next_city(current_city, unvisited, pheromone, distances, alpha, beta)
+                next_city = select_next_city(
+                    current_city, unvisited, pheromone, distances, alpha, beta
+                )
                 path.append(next_city)
                 unvisited.remove(next_city)
                 current_city = next_city
@@ -139,11 +149,18 @@ def ant_colony_optimization(
 
         # Update pheromones and track the best path found
         pheromone, best_path, best_distance = update_pheromones(
-            pheromone, all_paths, distances, q, evaporation_rate, best_path, best_distance
+            pheromone,
+            all_paths,
+            distances,
+            q,
+            evaporation_rate,
+            best_path,
+            best_distance,
         )
 
     return best_path, best_distance
 
+
 if __name__ == "__main__":
     # Example usage
     best_path, best_distance = ant_colony_optimization(
@@ -153,7 +170,7 @@ def ant_colony_optimization(
         alpha=1.0,
         beta=5.0,
         evaporation_rate=0.7,
-        q=10
+        q=10,
     )
 
     print(f"Best path: {best_path}")

Diff for: strings/aho_corasick.py

@@ -2,14 +2,17 @@
 from collections import deque
 from typing import List, Dict
 
+
 class State:
     """Represents a state in the Aho-Corasick automaton."""
+
     def __init__(self, value: str):
         self.value = value
         self.next_states: List[int] = []
         self.fail_state: int = 0
         self.output: List[str] = []
 
+
 class Automaton:
     def __init__(self, keywords: List[str]):
         self.adlist: List[State] = [State("")]  # Initial root state
@@ -44,37 +47,50 @@ def set_fail_transitions(self) -> None:
         for node in self.adlist[0].next_states:
             q.append(node)
             self.adlist[node].fail_state = 0
-        
+
         while q:
             r = q.popleft()
             for child in self.adlist[r].next_states:
                 q.append(child)
                 state = self.adlist[r].fail_state
-                while (self.find_state_by_character(state, self.adlist[child].value) is None and state != 0):
+                while (
+                    self.find_state_by_character(state, self.adlist[child].value)
+                    is None
+                    and state != 0
+                ):
                     state = self.adlist[state].fail_state
-                
-                fail_state = self.find_state_by_character(state, self.adlist[child].value)
-                self.adlist[child].fail_state = fail_state if fail_state is not None else 0
-                self.adlist[child].output.extend(self.adlist[self.adlist[child].fail_state].output)
+
+                fail_state = self.find_state_by_character(
+                    state, self.adlist[child].value
+                )
+                self.adlist[child].fail_state = (
+                    fail_state if fail_state is not None else 0
+                )
+                self.adlist[child].output.extend(
+                    self.adlist[self.adlist[child].fail_state].output
+                )
 
     def search_in(self, string: str) -> Dict[str, List[int]]:
         """
         Search for keywords in the given string.
 
         Returns a dictionary with keywords and the list of their occurrences.
-        
+
         Example:
         >>> A = Automaton(["what", "hat", "ver", "er"])
         >>> A.search_in("whatever, err ... , wherever")
         {'what': [0], 'hat': [1], 'ver': [5, 25], 'er': [6, 10, 22, 26]}
         """
         result: Dict[str, List[int]] = {}
         current_state = 0
-        
+
         for i in range(len(string)):
-            while self.find_state_by_character(current_state, string[i]) is None and current_state != 0:
+            while (
+                self.find_state_by_character(current_state, string[i]) is None
+                and current_state != 0
+            ):
                 current_state = self.adlist[current_state].fail_state
-            
+
             next_state = self.find_state_by_character(current_state, string[i])
             if next_state is None:
                 current_state = 0
@@ -84,10 +100,11 @@ def search_in(self, string: str) -> Dict[str, List[int]]:
                     if key not in result:
                         result[key] = []
                     result[key].append(i - len(key) + 1)
-        
+
         return result
 
 
 if __name__ == "__main__":
     import doctest
+
     doctest.testmod()