psf/black code formatting (#1277)

data_structures/hashing/double_hash.py

@@ -8,13 +8,17 @@ class DoubleHash(HashTable):
     """
         Hash Table example with open addressing and Double Hash
     """
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
     def __hash_function_2(self, value, data):
 
-        next_prime_gt = next_prime(value % self.size_table) \
-            if not check_prime(value % self.size_table) else value % self.size_table  #gt = bigger than
+        next_prime_gt = (
+            next_prime(value % self.size_table)
+            if not check_prime(value % self.size_table)
+            else value % self.size_table
+        )  # gt = bigger than
         return next_prime_gt - (data % next_prime_gt)
 
     def __hash_double_function(self, key, data, increment):
@@ -25,9 +29,14 @@ class DoubleHash(HashTable):
         new_key = self.hash_function(data)
 
         while self.values[new_key] is not None and self.values[new_key] != key:
-            new_key = self.__hash_double_function(key, data, i) if \
-                self.balanced_factor() >= self.lim_charge else None
-            if new_key is None: break 
-            else: i += 1
+            new_key = (
+                self.__hash_double_function(key, data, i)
+                if self.balanced_factor() >= self.lim_charge
+                else None
+            )
+            if new_key is None:
+                break
+            else:
+                i += 1
 
         return new_key

data_structures/hashing/hash_table.py

@@ -19,8 +19,9 @@ class HashTable:
         return self._keys
 
     def balanced_factor(self):
-        return sum([1 for slot in self.values
-                    if slot is not None]) / (self.size_table * self.charge_factor)
+        return sum([1 for slot in self.values if slot is not None]) / (
+            self.size_table * self.charge_factor
+        )
 
     def hash_function(self, key):
         return key % self.size_table
@@ -46,8 +47,7 @@ class HashTable:
     def _colision_resolution(self, key, data=None):
         new_key = self.hash_function(key + 1)
 
-        while self.values[new_key] is not None \
-                and self.values[new_key] != key:
+        while self.values[new_key] is not None and self.values[new_key] != key:
 
             if self.values.count(None) > 0:
                 new_key = self.hash_function(new_key + 1)
@@ -61,7 +61,7 @@ class HashTable:
         survivor_values = [value for value in self.values if value is not None]
         self.size_table = next_prime(self.size_table, factor=2)
         self._keys.clear()
-        self.values = [None] * self.size_table #hell's pointers D: don't DRY ;/
+        self.values = [None] * self.size_table  # hell's pointers D: don't DRY ;/
         map(self.insert_data, survivor_values)
 
     def insert_data(self, data):
@@ -80,5 +80,3 @@ class HashTable:
             else:
                 self.rehashing()
                 self.insert_data(data)
-
-

data_structures/hashing/hash_table_with_linked_list.py

@@ -7,18 +7,20 @@ class HashTableWithLinkedList(HashTable):
         super().__init__(*args, **kwargs)
 
     def _set_value(self, key, data):
-        self.values[key] = deque([]) if self.values[key] is None else self.values[key]  
+        self.values[key] = deque([]) if self.values[key] is None else self.values[key]
         self.values[key].appendleft(data)
         self._keys[key] = self.values[key]
 
     def balanced_factor(self):
-        return sum([self.charge_factor - len(slot) for slot in self.values])\
-               / self.size_table * self.charge_factor
-    
+        return (
+            sum([self.charge_factor - len(slot) for slot in self.values])
+            / self.size_table
+            * self.charge_factor
+        )
+
     def _colision_resolution(self, key, data=None):
-        if not (len(self.values[key]) == self.charge_factor
-                and self.values.count(None) == 0):
+        if not (
+            len(self.values[key]) == self.charge_factor and self.values.count(None) == 0
+        ):
             return key
         return super()._colision_resolution(key, data)
-
-

data_structures/hashing/number_theory/prime_numbers.py

@@ -5,25 +5,25 @@
 
 
 def check_prime(number):
-        """
+    """
             it's not the best solution
         """
-        special_non_primes = [0,1,2]
-        if number in special_non_primes[:2]:
-            return 2
-        elif number == special_non_primes[-1]:
-            return 3
-            
-        return all([number % i for i in range(2, number)])
+    special_non_primes = [0, 1, 2]
+    if number in special_non_primes[:2]:
+        return 2
+    elif number == special_non_primes[-1]:
+        return 3
+
+    return all([number % i for i in range(2, number)])
 
 
 def next_prime(value, factor=1, **kwargs):
     value = factor * value
     first_value_val = value
-    
+
     while not check_prime(value):
         value += 1 if not ("desc" in kwargs.keys() and kwargs["desc"] is True) else -1
-    
+
     if value == first_value_val:
         return next_prime(value + 1, **kwargs)
     return value

data_structures/hashing/quadratic_probing.py

@@ -7,18 +7,21 @@ class QuadraticProbing(HashTable):
     """
         Basic Hash Table example with open addressing using Quadratic Probing 
     """
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
     def _colision_resolution(self, key, data=None):
         i = 1
-        new_key = self.hash_function(key + i*i)
+        new_key = self.hash_function(key + i * i)
 
-        while self.values[new_key] is not None \
-                and self.values[new_key] != key:
+        while self.values[new_key] is not None and self.values[new_key] != key:
             i += 1
-            new_key = self.hash_function(key + i*i) if not \
-                self.balanced_factor() >= self.lim_charge else None
+            new_key = (
+                self.hash_function(key + i * i)
+                if not self.balanced_factor() >= self.lim_charge
+                else None
+            )
 
             if new_key is None:
                 break