Fix astar (#1966)

* Fix astar

Single character variable names are old school.

* fixup! Format Python code with psf/black push

* Tuple

* updating DIRECTORY.md

Co-authored-by: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>

DIRECTORY.md

@@ -266,6 +266,7 @@
     * [Test Linear Algebra](https://github.com/TheAlgorithms/Python/blob/master/linear_algebra/src/test_linear_algebra.py)
 
 ## Machine Learning
+  * [Astar](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/astar.py)
   * [Decision Tree](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/decision_tree.py)
   * [Gaussian Naive Bayes](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/gaussian_naive_bayes.py)
   * [Gradient Descent](https://github.com/TheAlgorithms/Python/blob/master/machine_learning/gradient_descent.py)
@@ -327,6 +328,7 @@
   * [Hardy Ramanujanalgo](https://github.com/TheAlgorithms/Python/blob/master/maths/hardy_ramanujanalgo.py)
   * [Is Square Free](https://github.com/TheAlgorithms/Python/blob/master/maths/is_square_free.py)
   * [Jaccard Similarity](https://github.com/TheAlgorithms/Python/blob/master/maths/jaccard_similarity.py)
+  * [Kadanes](https://github.com/TheAlgorithms/Python/blob/master/maths/kadanes.py)
   * [Karatsuba](https://github.com/TheAlgorithms/Python/blob/master/maths/karatsuba.py)
   * [Kth Lexicographic Permutation](https://github.com/TheAlgorithms/Python/blob/master/maths/kth_lexicographic_permutation.py)
   * [Largest Of Very Large Numbers](https://github.com/TheAlgorithms/Python/blob/master/maths/largest_of_very_large_numbers.py)

machine_learning/astar.py

@@ -1,6 +1,4 @@
-import numpy as np
-
-'''
+"""
 The A* algorithm combines features of uniform-cost search and pure
 heuristic search to efficiently compute optimal solutions.
 A* algorithm is a best-first search algorithm in which the cost
@@ -11,11 +9,12 @@ from node n to a goal.A* algorithm introduces a heuristic into a
 regular graph-searching algorithm,
 essentially planning ahead at each step so a more optimal decision
 is made.A* also known as the algorithm with brains
-'''
+"""
+import numpy as np
 
 
 class Cell(object):
-    '''
+    """
     Class cell represents a cell in the world which have the property
     position : The position of the represented by  tupleof x and y
     co-ordinates initially set to (0,0)
@@ -24,7 +23,8 @@ class Cell(object):
     g,h,f : The parameters for constructing the heuristic function
     which can be any function. for simplicity used line
     distance
-    '''
+    """
+
     def __init__(self):
         self.position = (0, 0)
         self.parent = None
@@ -32,10 +32,12 @@ class Cell(object):
         self.g = 0
         self.h = 0
         self.f = 0
-    '''
+
+    """
     overrides equals method because otherwise cell assign will give
     wrong results
-    '''
+    """
+
     def __eq__(self, cell):
         return self.position == cell.position
 
@@ -44,12 +46,11 @@ class Cell(object):
 
 
 class Gridworld(object):
-
-    '''
+    """
     Gridworld class represents the  external world here a grid M*M
     matrix
-    w    : create a numpy array with the given world_size default is 5
-    '''
+    world_size: create a numpy array with the given world_size default is 5
+    """
 
     def __init__(self, world_size=(5, 5)):
         self.w = np.zeros(world_size)
@@ -59,40 +60,41 @@ class Gridworld(object):
     def show(self):
         print(self.w)
 
-    '''
-    get_neighbours
-    As the name suggests this function will return the neighbours of
-    the a particular cell
-    '''
     def get_neigbours(self, cell):
+        """
+        Return the neighbours of cell
+        """
         neughbour_cord = [
-            (-1, -1), (-1, 0), (-1, 1), (0, -1),
-            (0, 1), (1, -1), (1, 0), (1, 1)]
+            (-1, -1),
+            (-1, 0),
+            (-1, 1),
+            (0, -1),
+            (0, 1),
+            (1, -1),
+            (1, 0),
+            (1, 1),
+        ]
         current_x = cell.position[0]
         current_y = cell.position[1]
         neighbours = []
         for n in neughbour_cord:
             x = current_x + n[0]
             y = current_y + n[1]
-            if (
-               (x >= 0 and x < self.world_x_limit) and
-               (y >= 0 and y < self.world_y_limit)):
+            if 0 <= x < self.world_x_limit and 0 <= y < self.world_y_limit:
                 c = Cell()
                 c.position = (x, y)
                 c.parent = cell
                 neighbours.append(c)
         return neighbours
 
-'''
-Implementation of a start algorithm
-world : Object of the world object
-start : Object of the cell as  start position
-stop  : Object of the cell as goal position
-'''
-
 
 def astar(world, start, goal):
-    '''
+    """
+    Implementation of a start algorithm
+    world : Object of the world object
+    start : Object of the cell as  start position
+    stop  : Object of the cell as goal position
+
     >>> p = Gridworld()
     >>> start = Cell()
     >>> start.position = (0,0)
@@ -100,7 +102,7 @@ def astar(world, start, goal):
     >>> goal.position = (4,4)
     >>> astar(p, start, goal)
     [(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]
-    '''
+    """
     _open = []
     _closed = []
     _open.append(start)
@@ -118,7 +120,7 @@ def astar(world, start, goal):
             n.g = current.g + 1
             x1, y1 = n.position
             x2, y2 = goal.position
-            n.h = (y2 - y1)**2 + (x2 - x1)**2
+            n.h = (y2 - y1) ** 2 + (x2 - x1) ** 2
             n.f = n.h + n.g
 
             for c in _open:
@@ -130,23 +132,19 @@ def astar(world, start, goal):
         path.append(current.position)
         current = current.parent
     path.append(current.position)
-    path = path[::-1]
-    return path
+    return path[::-1]
 
-if __name__ == '__main__':
-    '''
-    sample run
-    '''
-#   object for the world
-    p = Gridworld()
-#   stat position and Goal
+
+if __name__ == "__main__":
+    world = Gridworld()
+    #   stat position and Goal
     start = Cell()
     start.position = (0, 0)
     goal = Cell()
     goal.position = (4, 4)
-    print("path from {} to {} ".format(start.position, goal.position))
-    s = astar(p, start, goal)
-#   Just for visual Purpose
+    print(f"path from {start.position} to {goal.position}")
+    s = astar(world, start, goal)
+    #   Just for visual reasons
     for i in s:
-        p.w[i] = 1
-    print(p.w)
+        world.w[i] = 1
+    print(world.w)

maths/kadanes.py

@@ -3,7 +3,7 @@ Kadane's algorithm to get maximum subarray sum
 https://medium.com/@rsinghal757/kadanes-algorithm-dynamic-programming-how-and-why-does-it-work-3fd8849ed73d
 https://en.wikipedia.org/wiki/Maximum_subarray_problem
 """
-test_data = ([-2, -8, -9], [2, 8, 9], [-1, 0, 1], [0, 0], [])
+test_data: tuple = ([-2, -8, -9], [2, 8, 9], [-1, 0, 1], [0, 0], [])
 
 
 def negative_exist(arr: list) -> int: