various spelling corrections in documentation & several variables naming conventions fix

Author: matkosoric

backtracking/n_queens.py

@@ -42,7 +42,7 @@ def solve(board, row):
     """
     It creates a state space tree and calls the safe function until it receives a 
     False Boolean and terminates that branch and backtracks to the next 
-    poosible solution branch.
+    possible solution branch.
     """
     if row >= len(board):
         """
@@ -56,7 +56,7 @@ def solve(board, row):
         return
     for i in range(len(board)):
         """
-        For every row it iterates through each column to check if it is feesible to place a 
+        For every row it iterates through each column to check if it is feasible to place a 
         queen there.
         If all the combinations for that particular branch are successful the board is 
         reinitialized for the next possible combination.

ciphers/onepad_cipher.py

@@ -3,7 +3,7 @@
 
 class Onepad:
     def encrypt(self, text):
-        """Function to encrypt text using psedo-random numbers"""
+        """Function to encrypt text using pseudo-random numbers"""
         plain = [ord(i) for i in text]
         key = []
         cipher = []
@@ -15,7 +15,7 @@ def encrypt(self, text):
         return cipher, key
 
     def decrypt(self, cipher, key):
-        """Function to decrypt text using psedo-random numbers."""
+        """Function to decrypt text using pseudo-random numbers."""
         plain = []
         for i in range(len(key)):
             p = int((cipher[i] - (key[i]) ** 2) / key[i])

data_structures/binary_tree/binary_search_tree.py

@@ -28,16 +28,16 @@ def __str__(self):
         """
         return str(self.root)
 
-    def __reassign_nodes(self, node, newChildren):
-        if newChildren is not None:  # reset its kids
-            newChildren.parent = node.parent
+    def __reassign_nodes(self, node, new_children):
+        if new_children is not None:  # reset its kids
+            new_children.parent = node.parent
         if node.parent is not None:  # reset its parent
             if self.is_right(node):  # If it is the right children
-                node.parent.right = newChildren
+                node.parent.right = new_children
             else:
-                node.parent.left = newChildren
+                node.parent.left = new_children
         else:
-            self.root = newChildren
+            self.root = new_children
 
     def is_right(self, node):
         return node == node.parent.right
@@ -117,39 +117,39 @@ def remove(self, value):
             elif node.right is None:  # Has only left children
                 self.__reassign_nodes(node, node.left)
             else:
-                tmpNode = self.get_max(
+                tmp_node = self.get_max(
                     node.left
-                )  #  Gets the max value of the left branch
-                self.remove(tmpNode.value)
+                )  # Gets the max value of the left branch
+                self.remove(tmp_node.value)
                 node.value = (
-                    tmpNode.value
-                )  #  Assigns the value to the node to delete and keesp tree structure
+                    tmp_node.value
+                )  # Assigns the value to the node to delete and keep tree structure
 
     def preorder_traverse(self, node):
         if node is not None:
-            yield node  #  Preorder Traversal
+            yield node  # Preorder Traversal
             yield from self.preorder_traverse(node.left)
             yield from self.preorder_traverse(node.right)
 
-    def traversal_tree(self, traversalFunction=None):
+    def traversal_tree(self, traversal_function=None):
         """
         This function traversal the tree.
         You can pass a function to traversal the tree as needed by client code
         """
-        if traversalFunction is None:
+        if traversal_function is None:
             return self.preorder_traverse(self.root)
         else:
-            return traversalFunction(self.root)
+            return traversal_function(self.root)
 
 
 def postorder(curr_node):
     """
     postOrder (left, right, self)
     """
-    nodeList = list()
+    node_list = list()
     if curr_node is not None:
-        nodeList = postorder(curr_node.left) + postorder(curr_node.right) + [curr_node]
-    return nodeList
+        node_list = postorder(curr_node.left) + postorder(curr_node.right) + [curr_node]
+    return node_list
 
 
 def binary_search_tree():

data_structures/binary_tree/number_of_possible_binary_trees.py

@@ -82,7 +82,7 @@ def binary_tree_count(node_count: int) -> int:
     """
     Return the number of possible of binary trees.
     :param n: number of nodes
-    :return: Number of possilble binary trees
+    :return: Number of possible binary trees
 
     >>> binary_tree_count(5)
     5040

divide_and_conquer/convex_hull.py

@@ -344,19 +344,19 @@ def convex_hull_recursive(points):
     right_most_point = points[n - 1]
 
     convex_set = {left_most_point, right_most_point}
-    upperhull = []
-    lowerhull = []
+    upper_hull = []
+    lower_hull = []
 
     for i in range(1, n - 1):
         det = _det(left_most_point, right_most_point, points[i])
 
         if det > 0:
-            upperhull.append(points[i])
+            upper_hull.append(points[i])
         elif det < 0:
-            lowerhull.append(points[i])
+            lower_hull.append(points[i])
 
-    _construct_hull(upperhull, left_most_point, right_most_point, convex_set)
-    _construct_hull(lowerhull, right_most_point, left_most_point, convex_set)
+    _construct_hull(upper_hull, left_most_point, right_most_point, convex_set)
+    _construct_hull(lower_hull, right_most_point, left_most_point, convex_set)
 
     return sorted(convex_set)
 

dynamic_programming/bitmask.py

@@ -25,41 +25,41 @@ def __init__(self, task_performed, total):
 
         self.task = defaultdict(list)  # stores the list of persons for each task
 
-        # finalmask is used to check if all persons are included by setting all bits to 1
-        self.finalmask = (1 << len(task_performed)) - 1
+        # final_mask is used to check if all persons are included by setting all bits to 1
+        self.final_mask = (1 << len(task_performed)) - 1
 
-    def CountWaysUtil(self, mask, taskno):
+    def CountWaysUtil(self, mask, task_no):
 
         # if mask == self.finalmask all persons are distributed tasks, return 1
-        if mask == self.finalmask:
+        if mask == self.final_mask:
             return 1
 
         # if not everyone gets the task and no more tasks are available, return 0
-        if taskno > self.total_tasks:
+        if task_no > self.total_tasks:
             return 0
 
         # if case already considered
-        if self.dp[mask][taskno] != -1:
-            return self.dp[mask][taskno]
+        if self.dp[mask][task_no] != -1:
+            return self.dp[mask][task_no]
 
         # Number of ways when we don't this task in the arrangement
-        total_ways_util = self.CountWaysUtil(mask, taskno + 1)
+        total_ways_util = self.CountWaysUtil(mask, task_no + 1)
 
         # now assign the tasks one by one to all possible persons and recursively assign for the remaining tasks.
-        if taskno in self.task:
-            for p in self.task[taskno]:
+        if task_no in self.task:
+            for p in self.task[task_no]:
 
                 # if p is already given a task
                 if mask & (1 << p):
                     continue
 
                 # assign this task to p and change the mask value. And recursively assign tasks with the new mask value.
-                total_ways_util += self.CountWaysUtil(mask | (1 << p), taskno + 1)
+                total_ways_util += self.CountWaysUtil(mask | (1 << p), task_no + 1)
 
         # save the value.
-        self.dp[mask][taskno] = total_ways_util
+        self.dp[mask][task_no] = total_ways_util
 
-        return self.dp[mask][taskno]
+        return self.dp[mask][task_no]
 
     def countNoOfWays(self, task_performed):
 

graphs/bellman_ford.py

@@ -8,7 +8,7 @@ def printDist(dist, V):
 
 
 def BellmanFord(graph: List[Dict[str, int]], V: int, E: int, src: int) -> int:
-    r"""
+    """
     Returns shortest paths from a vertex src to all 
     other vertices.
     """

graphs/directed_and_undirected_(weighted)_graph.py

@@ -3,7 +3,7 @@
 import math as math
 import time
 
-# the dfault weight is 1 if not assigned but all the implementation is weighted
+# the default weight is 1 if not assigned but all the implementation is weighted
 
 
 class DirectedGraph:

graphs/minimum_spanning_tree_prims.py

@@ -6,13 +6,13 @@ def PrimsAlgorithm(l):
 
     nodePosition = []
 
-    def getPosition(vertex):
+    def get_position(vertex):
         return nodePosition[vertex]
 
-    def setPosition(vertex, pos):
+    def set_position(vertex, pos):
         nodePosition[vertex] = pos
 
-    def topToBottom(heap, start, size, positions):
+    def top_to_bottom(heap, start, size, positions):
         if start > size // 2 - 1:
             return
         else:
@@ -28,14 +28,14 @@ def topToBottom(heap, start, size, positions):
                 heap[m], positions[m] = heap[start], positions[start]
                 heap[start], positions[start] = temp, temp1
 
-                temp = getPosition(positions[m])
-                setPosition(positions[m], getPosition(positions[start]))
-                setPosition(positions[start], temp)
+                temp = get_position(positions[m])
+                set_position(positions[m], get_position(positions[start]))
+                set_position(positions[start], temp)
 
-                topToBottom(heap, m, size, positions)
+                top_to_bottom(heap, m, size, positions)
 
     # Update function if value of any node in min-heap decreases
-    def bottomToTop(val, index, heap, position):
+    def bottom_to_top(val, index, heap, position):
         temp = position[index]
 
         while index != 0:
@@ -47,27 +47,27 @@ def bottomToTop(val, index, heap, position):
             if val < heap[parent]:
                 heap[index] = heap[parent]
                 position[index] = position[parent]
-                setPosition(position[parent], index)
+                set_position(position[parent], index)
             else:
                 heap[index] = val
                 position[index] = temp
-                setPosition(temp, index)
+                set_position(temp, index)
                 break
             index = parent
         else:
             heap[0] = val
             position[0] = temp
-            setPosition(temp, 0)
+            set_position(temp, 0)
 
     def heapify(heap, positions):
         start = len(heap) // 2 - 1
         for i in range(start, -1, -1):
-            topToBottom(heap, i, len(heap), positions)
+            top_to_bottom(heap, i, len(heap), positions)
 
     def deleteMinimum(heap, positions):
         temp = positions[0]
         heap[0] = sys.maxsize
-        topToBottom(heap, 0, len(heap), positions)
+        top_to_bottom(heap, 0, len(heap), positions)
         return temp
 
     visited = [0 for i in range(len(l))]
@@ -96,9 +96,9 @@ def deleteMinimum(heap, positions):
             TreeEdges.append((Nbr_TV[vertex], vertex))
             visited[vertex] = 1
             for v in l[vertex]:
-                if visited[v[0]] == 0 and v[1] < Distance_TV[getPosition(v[0])]:
-                    Distance_TV[getPosition(v[0])] = v[1]
-                    bottomToTop(v[1], getPosition(v[0]), Distance_TV, Positions)
+                if visited[v[0]] == 0 and v[1] < Distance_TV[get_position(v[0])]:
+                    Distance_TV[get_position(v[0])] = v[1]
+                    bottom_to_top(v[1], get_position(v[0]), Distance_TV, Positions)
                     Nbr_TV[v[0]] = vertex
     return TreeEdges