Merge pull request #2520 from Shikhar9425/patch-4

Maze.py

Author: avinashkranjan

AI-based AI Maze Solver/README.md

@@ -0,0 +1,44 @@
+Package/Script Name: AI-based AI Maze Solver
+
+Short Description: AI-based AI Maze Solver is a Python script that implements an AI algorithm to solve a maze automatically. The AI uses the A* (A-Star) search algorithm with a heuristic function to efficiently navigate through the maze and find the shortest path to the goal.
+
+Functionalities/Script:
+
+MazeSolver class: Represents the AI-based maze solver.
+A* algorithm: Implements the A* search algorithm with a heuristic function to find the shortest path.
+Heuristic function: Calculates the estimated cost (heuristic) from a cell to the goal to guide the A* search.
+Setup Instructions:
+
+Make sure you have Python installed on your system (Python 3.6 or higher).
+Download the AI_maze_solver.py file from the repository or package.
+Explanation of Script:
+The AI-based AI Maze Solver script enables you to solve mazes automatically using the A* search algorithm. The A* algorithm combines the cost to reach a cell (path cost) with an estimated cost to the goal (heuristic) to efficiently explore the maze and find the shortest path.
+
+Usage:
+
+Create a maze representation as a 2D array, where 0 represents empty cells, 1 represents obstacles/walls, and 2 represents the starting position. For example:
+python
+Copy code
+maze = [
+    [1, 1, 0, 0, 0],
+    [0, 1, 1, 0, 1],
+    [0, 0, 0, 0, 1],
+    [1, 1, 0, 1, 0],
+    [2, 0, 0, 1, 1],
+]
+Initialize the MazeSolver class with the maze.
+python
+Copy code
+from AI_maze_solver import MazeSolver
+
+maze_solver = MazeSolver(maze)
+Use the find_path() method to get the shortest path from the starting position to the goal.
+python
+Copy code
+path = maze_solver.find_path()
+print("Shortest Path:", path)
+Output:
+The AI-based AI Maze Solver script will output the shortest path from the starting position to the goal in the maze.
+
+Author:
+Shikhar9425

AI-based AI Maze Solver/maze.py

@@ -0,0 +1,87 @@
+import heapq
+import random
+
+class MazeSolver:
+    def __init__(self, maze):
+        self.maze = maze
+        self.rows = len(maze)
+        self.cols = len(maze[0])
+        self.start = (0, 0)
+        self.goal = (self.rows - 1, self.cols - 1)
+
+    def get_neighbors(self, node):
+        row, col = node
+        neighbors = []
+        if row > 0 and not self.maze[row - 1][col]:
+            neighbors.append((row - 1, col))
+        if row < self.rows - 1 and not self.maze[row + 1][col]:
+            neighbors.append((row + 1, col))
+        if col > 0 and not self.maze[row][col - 1]:
+            neighbors.append((row, col - 1))
+        if col < self.cols - 1 and not self.maze[row][col + 1]:
+            neighbors.append((row, col + 1))
+        return neighbors
+
+    def heuristic(self, node):
+        return abs(node[0] - self.goal[0]) + abs(node[1] - self.goal[1])
+
+    def solve(self):
+        open_set = []
+        closed_set = set()
+        g_score = {self.start: 0}
+        f_score = {self.start: self.heuristic(self.start)}
+        heapq.heappush(open_set, (f_score[self.start], self.start))
+
+        while open_set:
+            _, current = heapq.heappop(open_set)
+
+            if current == self.goal:
+                path = []
+                while current in g_score:
+                    path.append(current)
+                    current = g_score[current]
+                return path[::-1]
+
+            closed_set.add(current)
+
+            for neighbor in self.get_neighbors(current):
+                if neighbor in closed_set:
+                    continue
+                tentative_g_score = g_score[current] + 1
+
+                if neighbor not in g_score or tentative_g_score < g_score[neighbor]:
+                    g_score[neighbor] = tentative_g_score
+                    f_score[neighbor] = tentative_g_score + self.heuristic(neighbor)
+                    heapq.heappush(open_set, (f_score[neighbor], neighbor))
+
+        return None
+
+def generate_random_maze(rows, cols, obstacle_probability):
+    return [[random.random() < obstacle_probability for _ in range(cols)] for _ in range(rows)]
+
+def print_maze(maze):
+    for row in maze:
+        print("".join(["#" if cell else " " for cell in row]))
+
+def main():
+    rows = 10
+    cols = 10
+    obstacle_probability = 0.2
+
+    maze = generate_random_maze(rows, cols, obstacle_probability)
+    print("Random Maze:")
+    print_maze(maze)
+
+    maze_solver = MazeSolver(maze)
+    path = maze_solver.solve()
+
+    if path:
+        print("\nSolution Path:")
+        for node in path:
+            maze[node[0]][node[1]] = True  # Marking the path in the maze
+        print_maze(maze)
+    else:
+        print("\nNo path found!")
+
+if __name__ == "__main__":
+    main()