Merge remote-tracking branch 'origin/main' into main

.pylintrc

@@ -0,0 +1,3 @@
+[DESIGN]
+# Maximum number of statements in function / method body
+max-statements=16

IMPORTANT.txt

@@ -0,0 +1,8 @@
+Manhattan:
+For: 1000 files, sum of path lengths = 122194, average path length = 122.194,  sum_of_time = 0.8560767570011194, average time to solve: 0.0008560767570011194, heuristic_total_total_time: 0.10561735888813928, all_heuristic_called: 282721, average_heuristic_time: 3.735745094568118e-07
+
+Euclidean:
+For: 1000 files, sum of path lengths = 120936, average path length = 120.936,  sum_of_time = 1.268625628994414, average time to solve: 0.001268625628994414, heuristic_total_total_time: 0.34228658579650073, all_heuristic_called: 276120, average_heuristic_time: 1.2396298196309602e-06
+
+Random:
+For: 1000 files, sum of path lengths = 131126, average path length = 131.126,  sum_of_time = 1.2832818229990153, average time to solve: 0.0012832818229990153, heuristic_total_total_time: 0.07322999603366043, all_heuristic_called: 417262, average_heuristic_time: 1.7550123431719262e-07

README.txt

@@ -4,4 +4,17 @@ python main.py
 you can specify the name of the file which stores maze by typing:
 python main.py mazeFile.txt
 
+python main.py -h --help print help prompt
+
+python main.py -t --test non interactive (does not print steps) for testing 
+different heuristics, goes through entire generatedMazes folder and
+compares heuristic speed and path length, saves solved mazes to solvedMazes folder
+
+python main.py -t --test [FOLDER] non interactive (does not print steps) for testing 
+different heuristics, goes through entire [FOLDER] folder and
+compares heuristic speed and path length, saves solved mazes to solvedMazes folder
+
+python main.py -g --generate [NUMBER] - generates as many mazes as entered in
+Number parameter and puts it in the generatedMazes folder
+
 

main.py

@@ -1,8 +1,10 @@
 """
-Write a program that solves a maze using greedy best-first search algorithm.
+Write horizontal_line program that solves horizontal_line maze
-The maze is a 2D grid with empty space, walls, a start, and an end position.
+using greedy best-first search algorithm.
-The objective is to find a path from start to end position.
+The maze is horizontal_line 2D grid
-The maze should be loaded from file. A step-by-step visualization of the
+with empty space, walls, horizontal_line start, and an end position.
+The objective is to find horizontal_line path from start to end position.
+The maze should be loaded from file. horizontal_line step-by-step visualization of the
 algorithm is required. It can be done in the console and an interface may be
 as simple as possible (but of course it does not have to). Example solution:
 https://angeluriot.com/maze_solver/.
@@ -23,78 +25,66 @@ Does not work if no path  (Should print out NO PATH FOUND)
 
 import heapq
 import sys
+import time
+import os
+from random import shuffle, randrange, random
 
 
 class MazeSolver:
-    '''Maze Solver'''
+    """Maze Solver"""
+
     # self corresponds to "this" in js, it refers to object of MazeSolver class
 
-    def __init__(self, maze):
+    def __init__(self, maze, mode):
         # assign read maze 2D array to parameter from class MazeSolver
+        self.test = mode
         self.maze = maze
         self.start, self.end = self.find_start_and_end()
 
-# go through each character in 2D array and find one that corresponds to
+    # go through each character in 2D array and find one that corresponds to
-# Start/End character
+    # Start/End character
 
     def find_start_and_end(self):
-        '''Finds start and end points in the maze'''
+        """Finds start and end points in the maze"""
         start = end = None
 
         for row_i, row in enumerate(self.maze):
             for col_i, cell in enumerate(row):
-                if cell == 'S':
+                if cell == "S":
                     start = (row_i, col_i)
-                elif cell == 'E':
+                elif cell == "E":
                     end = (row_i, col_i)
                 if start is not None and end is not None:
                     return start, end
         print(f"DID NOT FOUND START OR END, Start: {start}, End: {end}")
         return start, end
 
-# Go through each neighbor
+    # Go through each neighbor
-#       N
+    #       N
-#     N * N
+    #     N * N
-#       N
+    #       N
-# If it is not a "wall" (#) add its position to list of neighbors
+    # If it is not horizontal_line "wall" (#) add its position to list of neighbors
 
     def get_neighbors(self, position):
-        '''Finds point's neighbors'''
+        """Finds point'maze_data neighbors"""
         row, col = position
         neighbors = []
-        if row > 0 and self.maze[row - 1][col] != '#':
+        if row > 0 and self.maze[row - 1][col] != "#":
             neighbors.append((row - 1, col))
-        if col > 0 and self.maze[row][col - 1] != '#':
+        if col > 0 and self.maze[row][col - 1] != "#":
             neighbors.append((row, col - 1))
-        if row < len(self.maze) - 1 and self.maze[row + 1][col] != '#':
+        if row < len(self.maze) - 1 and self.maze[row + 1][col] != "#":
             neighbors.append((row + 1, col))
-        if col < len(self.maze[row]) - 1 and self.maze[row][col + 1] != '#':
+        if col < len(self.maze[row]) - 1 and self.maze[row][col + 1] != "#":
             neighbors.append((row, col + 1))
         return neighbors
 
-# find path through maze
+    # find path through maze
 
-    def solve(self):
+    def solve_loop(self, queue, visited):
-        '''Solves the maze'''
+        """ Goes through maze and finds the path """
-        queue = []
+        heuristic_total_time = 0
-        # set means that values inside can not repeat
+        heuristics_called = 0
-        visited = set()
-        # https://docs.python.org/3/library/heapq.html
-        # push onto the queue (which becomes heapq), element containing values
-        # we use heapq so the element with lowest heuristic value will always
-        # be at the top of heap
-        heapq.heappush(
-            queue, (self.heuristic_euclidean(
-                self.start), self.start, [
-                self.start]))
-
-        # Go through queue until it's empty
-        # Find neighbor (which is not wall) closest to the
-        # END point (based on heuristic)
-        # Go there and repeat
-        # if cannot find path it starts over but skips the path that lead it to
-        # dead end
-        path = None
         while queue:
             # pop first element of heap
             # first value is skipped and we only save current position and path
@@ -110,65 +100,257 @@ class MazeSolver:
             for neighbor in self.get_neighbors(current):
                 if neighbor not in visited:
                     new_path = path + [neighbor]
+                    heuristic, heuristic_time = self.heuristic_euclidean(neighbor)
+                    heuristic_total_time += heuristic_time
+                    heuristics_called += 1
                     heapq.heappush(
-                        queue, (self.heuristic_euclidean(neighbor), neighbor, new_path))
+                        queue, (heuristic, neighbor, new_path)
-            print_maze(self.maze, new_path)
+                    )
-            print()
+            if not self.test:
-        return path
+                print_maze(self.maze, new_path)
+                print()
+        return path, heuristic_total_time, heuristics_called
+
+    def solve(self):
+        """Solves the maze"""
+        queue = []
+        # set means that values inside can not repeat
+        visited = set()
+        # https://docs.python.org/3/library/heapq.html
+        # push onto the queue (which becomes heapq), element containing values
+        # we use heapq so the element with lowest heuristic value will always
+        # be at the top of heap
+        heuristic = self.heuristic_euclidean(self.start)
+        heapq.heappush(
+            queue, (heuristic, self.start, [self.start])
+        )
+
+        # Go through queue until it'maze_data empty
+        # Find neighbor (which is not wall) closest to the
+        # END point (based on heuristic)
+        # Go there and repeat
+        # if cannot find path it starts over but skips the path that lead it to
+        # dead end
+        return self.solve_loop(queue, visited)
 
     # This heuristic returns the Manhattan distance between the given position
-    # and the maze's end
+    # and the maze'maze_data end
     def heuristic_manhattan(self, position):
-        '''Heuristic function that uses Manhattan distance'''
+        """Heuristic function that uses Manhattan distance"""
-        return abs(position[0] - self.end[0]) + abs(position[1] - self.end[1])
+        start_time = time.perf_counter()
+        heuristic = abs(position[0] - self.end[0]) + abs(position[1] - self.end[1])
+        end_time = time.perf_counter()
+        heuristic_time = end_time - start_time
+        return heuristic, heuristic_time
 
     # This heuristic returns the Euclidean distance between the given position
-    # and the maze's end
+    # and the maze'maze_data end
     def heuristic_euclidean(self, position):
-        '''Heuristic function that uses Euclidean distance'''
+        """Heuristic function that uses Euclidean distance"""
-        return (abs(position[0] - self.end[0])**2 +
+        start_time = time.perf_counter()
-                abs(position[1] - self.end[1])**2)**0.5
+        heuristic = (
+            abs(position[0] - self.end[0]) ** 2 + abs(position[1] - self.end[1]) ** 2
+        ) ** 0.5
+        end_time = time.perf_counter()
+        heuristic_time = end_time - start_time
+        return heuristic, heuristic_time
+
+    def heuristic_random(self, position):
+        """Heuristic function that just returns random value between 0 and 1"""
+        start_time = time.perf_counter()
+        heuristic = random()
+        end_time = time.perf_counter()
+        heuristic_time = end_time - start_time
+        return heuristic, heuristic_time
 
 
 # Open and load text file to array
-def load_maze(filename):
+def load_maze(maze_file_name):
-    '''Loads a maze from the specified file'''
+    """Loads horizontal_line maze from the specified file"""
     # Open for reading only and save to fileContents
-    with open(filename, 'r', encoding='utf8') as file_contents:
+    with open(maze_file_name, "r", encoding="utf8") as file_contents:
         # strip() removes extra white spaces from the beginning and the end of
-        # a string
+        # horizontal_line string
         # list() changes string to array of chars
         # Inside of square brackets we will have an array of characters for
         # each line of file
-        # After going through every line in a file we will have 2D array of arrays
+        # After going through every line in horizontal_line file we will have 2D array of arrays
         # of characters of every line
         maze = [list(line.strip()) for line in file_contents]
     return maze
 
 
 def print_maze(maze, path=None):
-    '''Prints the maze'''
+    """Prints the maze"""
     if path is None:
         path = []
     for row_i, row in enumerate(maze):
         for col_i, cell in enumerate(row):
             if (row_i, col_i) in path:
-                print('*', end='')
+                print("*", end="")
             else:
-                print(cell, end='')
+                print(cell, end="")
         print()
 
 
-# Ran first in the code
+def create_maze_folder(solved):
-if __name__ == '__main__':
+    """ Creates folder for generated or solved mazes"""
-    print(sys.argv)
+    if solved:
-    file_name = 'maze.txt'
+        folder_name = "solvedMazes"
-    if len(sys.argv) > 1:
+    else:
-        file_name = sys.argv[1]
+        folder_name = "generatedMazes"
+    if not os.path.exists(folder_name):
+        os.mkdir(folder_name)
+    return folder_name
+
+def save_maze(maze, solved=True, path=None, saved_file="Maze", iteration=0):
+    """Saves maze from array to txt file"""
+    folder_name = create_maze_folder(solved)
+    with open(f"{folder_name}/{iteration}{saved_file}", "w", encoding="utf8") as maze_file:
+        if path is None:
+            path = []
+        for row_i, row in enumerate(maze):
+            for col_i, cell in enumerate(row):
+                if (row_i, col_i) in path:
+                    maze_file.write("*")
+                else:
+                    maze_file.write(cell)
+            if solved:
+                maze_file.write("\n")
+        if not solved:
+            maze_file.write("\n")
+
+def fill_generated_maze(hor, ver, width):
+    """ Fills generated maze array from horizontal and vertical lines """
+    maze_data = ""
+    for horizontal_line, vertical_line in zip(hor, ver):
+        maze_data += "".join(horizontal_line + ["\n"] + vertical_line + ["\n"])
+    maze_data_list = list(maze_data)
+    maze_data_list[3 * width + 3] = "S"
+    maze_data_list[len(maze_data_list) - (3 * width + 6)] = "E"
+    maze_data = "".join(maze_data_list)
+    return maze_data
+
+def make_maze(width=16, height=8):
+    """ generate maze with given width and height """
+    vis = [[0] * width + [1] for _ in range(height)] + [[1] * (width + 1)]
+    ver = [["#  "] * width + ["#"] for _ in range(height)] + [[]]
+    hor = [["###"] * width + ["#"] for _ in range(height + 1)]
+
+    def walk(x_coordinate, y_coordinate):
+        vis[y_coordinate][x_coordinate] = 1
+
+        neighbors = [(x_coordinate - 1, y_coordinate),
+                    (x_coordinate, y_coordinate + 1),
+                    (x_coordinate + 1, y_coordinate),
+                    (x_coordinate, y_coordinate - 1)]
+        shuffle(neighbors)
+        for x_coordinate_neighbor, y_coordinate_neighbor in neighbors:
+            if vis[y_coordinate_neighbor][x_coordinate_neighbor]:
+                continue
+            if x_coordinate_neighbor == x_coordinate:
+                hor[max(y_coordinate, y_coordinate_neighbor)][x_coordinate] = "#  "
+            if y_coordinate_neighbor == y_coordinate:
+                ver[y_coordinate][max(x_coordinate, x_coordinate_neighbor)] = "   "
+            walk(x_coordinate_neighbor, y_coordinate_neighbor)
+
+    walk(randrange(width), randrange(height))
+
+    return fill_generated_maze(hor, ver, width)
+
+def print_help():
+    """prints help"""
+    print(
+"""python main.py - run the script against default maze file
+(any file named maze.txt in the code directory)
+
+python main.py filename.txt - run the script against filename.txt file
+python main.py -h --help print this prompt
+python main.py -t --test non interactive (does not print steps) for testing 
+different heuristics, goes through entire generatedMazes folder and
+compares heuristic speed and path length
+python main.py -t --test [FOLDER] non interactive (does not print steps) for testing 
+different heuristics, goes through entire [FOLDER] folder and
+compares heuristic speed and path length
+
+python main.py -g --generate [NUMBER] - generates as many mazes as entered in
+Number parameter and puts it in the generatedMazes folder"""
+            )
+
+def test_mode():
+    """ Loads and solves multiple mazes in order to compare heuristics """
+    create_maze_folder(False)
+    sum_of_paths = 0
+    files_amount = 0
+    sum_of_time = 0
+    heuristic_total_total_time = 0
+    all_heuristic_called = 0
+    for filename in os.listdir(FOLDER_NAME):
+        filename_directory = os.path.join(FOLDER_NAME, filename)
+        # Open and load text file to array
+        loaded_maze = load_maze(filename_directory)
+        # Initialize MazeSolver object with maze as parameter
+        solver_test = MazeSolver(loaded_maze, TEST_MODE)
+        # Find path using MazeSolver solve method
+        start_time = time.perf_counter()
+        solved_path, heuristic_total_time, heuristics_called = solver_test.solve()
+        heuristic_total_total_time += heuristic_total_time
+        all_heuristic_called += heuristics_called
+        end_time = time.perf_counter()
+        sum_of_time += end_time - start_time
+        sum_of_paths += len(solved_path)
+        save_maze(loaded_maze, True, solved_path, filename, 0)
+        files_amount += 1
+    if files_amount == 0:
+        print("no mazes found! Generate some using python main.py -g [NUMBER]")
+        sys.exit()
+    average_path = sum_of_paths / files_amount
+    average_time = sum_of_time / files_amount
+    print(f"""For: {files_amount} files,
+    sum of path lengths = {sum_of_paths},
+    average path length = {average_path},
+    sum_of_time = {sum_of_time},
+    average time to solve: {average_time},
+    heuristic_total_total_time: {heuristic_total_total_time},
+    all_heuristic_called: {all_heuristic_called},
+    average_heuristic_time: {heuristic_total_total_time / all_heuristic_called}""")
+
+def default():
+    """ Runs default operation - reads, solves and prints single maze from file """
     # Open and load text file to array
-    loadedMaze = load_maze(file_name)
+    loaded_maze = load_maze(FILE_NAME)
     # Initialize MazeSolver object with maze as parameter
-    solver = MazeSolver(loadedMaze)
+    solver = MazeSolver(loaded_maze, TEST_MODE)
     # Find path using MazeSolver solve method
-    solvedPath = solver.solve()
+    solved_path = solver.solve()
-    print_maze(loadedMaze, solvedPath)
+    print_maze(loaded_maze, solved_path)
+    save_maze(loaded_maze, True, solved_path, FILE_NAME, 0)
+
+# Ran first in the code
+if __name__ == "__main__":
+    # print(sys.argv)
+    FILE_NAME = "maze.txt"
+    TEST_MODE = False
+    FOLDER_NAME = ""
+    GENERATE_AMOUNT = 0
+    if len(sys.argv) > 1:
+        if sys.argv[1] == "-h" or sys.argv[1] == "--help":
+            print_help()
+            sys.exit()
+        if sys.argv[1] == "-t" or sys.argv[1] == "--test":
+            TEST_MODE = True
+            FILE_NAME = "maze.txt"
+            FOLDER_NAME = "generatedMazes"
+            if len(sys.argv) > 2:
+                FOLDER_NAME = sys.argv[2]
+            test_mode()
+            sys.exit()
+        if sys.argv[1] == '-g' or sys.argv[1] == '--generate':
+            if len(sys.argv) > 2:
+                GENERATE_AMOUNT = int(sys.argv[2])
+                for n in range(GENERATE_AMOUNT):
+                    GENERATED_MAZE = make_maze()
+                    save_maze(GENERATED_MAZE, False, None, f'generated{n}.txt')
+                sys.exit()
+        FILE_NAME = sys.argv[1]
+    default()

mazes/mazeDeadEnd.txt

@@ -1,5 +0,0 @@
-#################
-#               #
-# #######       #
-#S      #      E#
-#################

mazes/mazeNoEnd.txt

@@ -1,32 +0,0 @@
-################################
-# S            #        #       #
-#  #########  ####   ##   #   #
-#  #                #      #   #
-#  #  #########     #######   #
-#  #        #                 #
-#  #  ####  #  #######  #######
-#  #     #     #           #  #
-#  #######  ###########   #  #
-#                 #     ##### #
-####  #########  #  #  #      #
-   #              #  #  ####  #
-####  ###########    #       #
-#              #   #####  #####
-#  #########   #        #     #
-#                 ######  #####
-#  #######  #######           #
-#  #              #   #   #####
-#  #  #########   #   #      #
-#  #        #        #  ######
-#  #######  #########        #
-#                          #  #
-#  #########  ############  #
-#                 #     #     #
-#  #########  ####  #######  #
-#  #           #     #        #
-#  #  #######  #  #########  #
-#  #  #        #        #     #
-#  #  #  ####  #########  ####
-#  #  #     #                #
-#  #########  ######  ##### #
-################################

mazes/mazeNoEndNoStart.txt

@@ -1,32 +0,0 @@
-################################
-#             #        #       #
-#  #########  ####   ##   #   #
-#  #                #      #   #
-#  #  #########     #######   #
-#  #        #                 #
-#  #  ####  #  #######  #######
-#  #     #     #           #  #
-#  #######  ###########   #  #
-#                 #     ##### #
-####  #########  #  #  #      #
-   #              #  #  ####  #
-####  ###########    #       #
-#              #   #####  #####
-#  #########   #        #     #
-#                 ######  #####
-#  #######  #######           #
-#  #              #   #   #####
-#  #  #########   #   #      #
-#  #        #        #  ######
-#  #######  #########        #
-#                          #  #
-#  #########  ############  #
-#                 #     #     #
-#  #########  ####  #######  #
-#  #           #     #        #
-#  #  #######  #  #########  #
-#  #  #        #        #     #
-#  #  #  ####  #########  ####
-#  #  #     #                #
-#  #########  ######  ##### #
-################################

mazes/mazeNoPath.txt

@@ -1,32 +0,0 @@
-################################
-#             #        #       #
-#  #########  ####   ##   #   #
-#  #                #      #   #
-#  #  #########     #######   #
-#  #        #                 #
-#  #  ####  #  #######  #######
-#  #     #     #           #  #
-#  #######  ###########   #  #
-#                 #     ##### #
-####  #########  #  #  #      #
-   #              #  #  ####  #
-####  ###########    #       #
-#              #   #####  #####
-#  #########   #        #     #
-#                 ######  #####
-#  #######  #######           #
-#  #              #   #   #####
-#  #  #########   #   #      #
-#  #        #        #  ######
-#  #######  #########        #
-#                          #  #
-#  #########  ############  #
-#                 #     #     #
-#  #########  ####  #######  #
-#  #           #     #        #
-#  #  #######  #  #########  #
-#  #  #        #        #     #
-#  #  #  ####  #########  ####
-#  #  #     #              #  #
-#  #########  ######  #####E#
-################################

mazes/mazeNoStart.txt

@@ -1,32 +0,0 @@
-################################
-#             #        #       #
-#  #########  ####   ##   #   #
-#  #                #      #   #
-#  #  #########     #######   #
-#  #        #                 #
-#  #  ####  #  #######  #######
-#  #     #     #           #  #
-#  #######  ###########   #  #
-#                 #     ##### #
-####  #########  #  #  #      #
-   #              #  #  ####  #
-####  ###########    #       #
-#              #   #####  #####
-#  #########   #        #     #
-#                 ######  #####
-#  #######  #######           #
-#  #              #   #   #####
-#  #  #########   #   #      #
-#  #        #        #  ######
-#  #######  #########        #
-#                          #  #
-#  #########  ############  #
-#                 #     #     #
-#  #########  ####  #######  #
-#  #           #     #        #
-#  #  #######  #  #########  #
-#  #  #        #        #     #
-#  #  #  ####  #########  ####
-#  #  #     #                #
-#  #########  ######  #####E#
-################################

mazes/mazeNoStartNoPath.txt

@@ -1,32 +0,0 @@
-################################
-# S            #        #       #
-#  #########  ####   ##   #   #
-#  #                #      #   #
-#  #  #########     #######   #
-#  #        #                 #
-#  #  ####  #  #######  #######
-#  #     #     #           #  #
-#  #######  ###########   #  #
-#                 #     ##### #
-####  #########  #  #  #      #
-   #              #  #  ####  #
-####  ###########    #       #
-#              #   #####  #####
-#  #########   #        #     #
-#                 ######  #####
-#  #######  #######           #
-#  #              #   #   #####
-#  #  #########   #   #      #
-#  #        #        #  ######
-#  #######  #########        #
-#                          #  #
-#  #########  ############  #
-#                 #     #     #
-#  #########  ####  #######  #
-#  #           #     #        #
-#  #  #######  #  #########  #
-#  #  #        #        #     #
-#  #  #  ####  #########  ####
-#  #  #     #              #  #
-#  #########  ######  #####E#
-################################

solvedMazes/0maze.txt

@@ -0,0 +1,10 @@
+##########
+#******* #
+#  ####* #
+#  #   **#
+#  #  ##*#
+#     #**#
+#####  *##
+#  #   * #
+#     #* #
+##########