Fixes unused variable errors in LGTM (TheAlgorithms#1746)

* Fixes unsed variable errors in LGTM

* Fixes integer check

* Fixes failing tests

Author: onlinejudge95

ciphers/mixed_keyword_cypher.py

@@ -29,9 +29,6 @@ def mixed_keyword(key="college", pt="UNIVERSITY"):
     # print(temp)
     alpha = []
     modalpha = []
-    # modalpha.append(temp)
-    dic = dict()
-    c = 0
     for i in range(65, 91):
         t = chr(i)
         alpha.append(t)

data_structures/binary_tree/binary_search_tree.py

@@ -76,7 +76,7 @@ def insert(self, *values):
 
     def search(self, value):
         if self.empty():
-            raise IndexError("Warning: Tree is empty! please use another. ")
+            raise IndexError("Warning: Tree is empty! please use another.")
         else:
             node = self.root
             # use lazy evaluation here to avoid NoneType Attribute error
@@ -112,7 +112,6 @@ def remove(self, value):
         if node is not None:
             if node.left is None and node.right is None:  # If it has no children
                 self.__reassign_nodes(node, None)
-                node = None
             elif node.left is None:  # Has only right children
                 self.__reassign_nodes(node, node.right)
             elif node.right is None:  # Has only left children
@@ -154,7 +153,7 @@ def postorder(curr_node):
 
 
 def binary_search_tree():
-    r"""
+    """
     Example
                   8
                  / \
@@ -164,15 +163,15 @@ def binary_search_tree():
                  / \   /
                 4   7 13
 
-        >>> t = BinarySearchTree().insert(8, 3, 6, 1, 10, 14, 13, 4, 7)
-        >>> print(" ".join(repr(i.value) for i in t.traversal_tree()))
-        8 3 1 6 4 7 10 14 13
-        >>> print(" ".join(repr(i.value) for i in t.traversal_tree(postorder)))
-        1 4 7 6 3 13 14 10 8
-        >>> BinarySearchTree().search(6)
-        Traceback (most recent call last):
-        ...
-        IndexError: Warning: Tree is empty! please use another. 
+    >>> t = BinarySearchTree().insert(8, 3, 6, 1, 10, 14, 13, 4, 7)
+    >>> print(" ".join(repr(i.value) for i in t.traversal_tree()))
+    8 3 1 6 4 7 10 14 13
+    >>> print(" ".join(repr(i.value) for i in t.traversal_tree(postorder)))
+    1 4 7 6 3 13 14 10 8
+    >>> BinarySearchTree().search(6)
+    Traceback (most recent call last):
+    ...
+    IndexError: Warning: Tree is empty! please use another.
     """
     testlist = (8, 3, 6, 1, 10, 14, 13, 4, 7)
     t = BinarySearchTree()
@@ -201,10 +200,8 @@ def binary_search_tree():
         print(t)
 
 
-二叉搜索树 = binary_search_tree
-
 if __name__ == "__main__":
     import doctest
 
     doctest.testmod()
-    binary_search_tree()
+    # binary_search_tree()

graphs/a_star.py

@@ -52,7 +52,6 @@ def search(grid, init, goal, cost, heuristic):
 
     while not found and not resign:
         if len(cell) == 0:
-            resign = True
             return "FAIL"
         else:
             cell.sort()  # to choose the least costliest action so as to move closer to the goal
@@ -61,7 +60,6 @@ def search(grid, init, goal, cost, heuristic):
             x = next[2]
             y = next[3]
             g = next[1]
-            f = next[0]
 
             if x == goal[0] and y == goal[1]:
                 found = True

hashes/hamming_code.py

@@ -5,29 +5,29 @@
 
 """
     * This code implement the Hamming code:
-        https://en.wikipedia.org/wiki/Hamming_code - In telecommunication, 
+        https://en.wikipedia.org/wiki/Hamming_code - In telecommunication,
     Hamming codes are a family of linear error-correcting codes. Hamming
-    codes can detect up to two-bit errors or correct one-bit errors 
-    without detection of uncorrected errors. By contrast, the simple 
-    parity code cannot correct errors, and can detect only an odd number 
-    of bits in error. Hamming codes are perfect codes, that is, they 
-    achieve the highest possible rate for codes with their block length 
+    codes can detect up to two-bit errors or correct one-bit errors
+    without detection of uncorrected errors. By contrast, the simple
+    parity code cannot correct errors, and can detect only an odd number
+    of bits in error. Hamming codes are perfect codes, that is, they
+    achieve the highest possible rate for codes with their block length
     and minimum distance of three.
 
     * the implemented code consists of:
         * a function responsible for encoding the message (emitterConverter)
             * return the encoded message
         * a function responsible for decoding the message (receptorConverter)
             * return the decoded message and a ack of data integrity
-    
+
     * how to use:
-            to be used you must declare how many parity bits (sizePari) 
+            to be used you must declare how many parity bits (sizePari)
         you want to include in the message.
             it is desired (for test purposes) to select a bit to be set
         as an error. This serves to check whether the code is working correctly.
-            Lastly, the variable of the message/word that must be desired to be 
+            Lastly, the variable of the message/word that must be desired to be
         encoded (text).
-    
+
     * how this work:
             declaration of variables (sizePari, be, text)
 
@@ -71,7 +71,7 @@ def emitterConverter(sizePar, data):
     """
     :param sizePar: how many parity bits the message must have
     :param data:  information bits
-    :return: message to be transmitted by unreliable medium 
+    :return: message to be transmitted by unreliable medium
             - bits of information merged with parity bits
 
     >>> emitterConverter(4, "101010111111")
@@ -84,7 +84,6 @@ def emitterConverter(sizePar, data):
     dataOut = []
     parity = []
     binPos = [bin(x)[2:] for x in range(1, sizePar + len(data) + 1)]
-    pos = [x for x in range(1, sizePar + len(data) + 1)]
 
     # sorted information data for the size of the output data
     dataOrd = []
@@ -188,7 +187,6 @@ def receptorConverter(sizePar, data):
     dataOut = []
     parity = []
     binPos = [bin(x)[2:] for x in range(1, sizePar + len(dataOutput) + 1)]
-    pos = [x for x in range(1, sizePar + len(dataOutput) + 1)]
 
     #  sorted information data for the size of the output data
     dataOrd = []

linear_algebra/src/polynom-for-points.py

@@ -68,7 +68,6 @@ def points_to_polynomial(coordinates):
         # put the y values into a vector
         vector = []
         while count_of_line < x:
-            count_in_line = 0
             vector.append(coordinates[count_of_line][1])
             count_of_line += 1
 

matrix/matrix_operation.py

@@ -111,12 +111,9 @@ def inverse(matrix):
 
 
 def _check_not_integer(matrix):
-    try:
-        rows = len(matrix)
-        cols = len(matrix[0])
+    if not isinstance(matrix, int) and not isinstance(matrix[0], int):
         return True
-    except TypeError:
-        raise TypeError("Cannot input an integer value, it must be a matrix")
+    raise TypeError("Expected a matrix, got int/list instead")
 
 
 def _shape(matrix):