diff --git a/DIRECTORY.md b/DIRECTORY.md index 27fb1a898..e5ec48e27 100644 --- a/DIRECTORY.md +++ b/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) diff --git a/machine_learning/astar.py b/machine_learning/astar.py index 2dd10b1d5..ec8f214ab 100644 --- a/machine_learning/astar.py +++ b/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) diff --git a/maths/kadanes_algorithm.py b/maths/kadanes.py similarity index 93% rename from maths/kadanes_algorithm.py rename to maths/kadanes.py index d02f238a0..d239d4a25 100644 --- a/maths/kadanes_algorithm.py +++ b/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: