This document describes a program to solve the 8 puzzle problem using best first search. It includes steps to create classes for actions, nodes, and the search algorithm. The node class generates heuristic values and possible moves. Best first search uses an open and closed list to search the state space, sorting by heuristic value. The program was tested on sample inputs and outputs execution time and number of steps.

1. Practical-4
1 | P a g e
Name:- Nayan Oza
Enrollment No :- 19012011102
AIM: Write a program to solve 8 puzzle problem using the Best First
search algorithm and also find Execution time, completeness of
algorithm, etc.
Consider following steps to create a program in python:
1. Create Enum named “Action” for this problem
2. Create Node class with support of compare node & sort node
3. Choose appropriate heuristic function to solve this problem and create
in Node
class
4. Create BestFirstSearch class with “execution” method
5. Output should be according to given image
6. Print execution time & number of steps needed to reach goal state
7. Don’t use any libraries or packages of python
8. Test Program according to given below test cases
Output 1:
Output 2:

2. Practical-4
2 | P a g e
Name:- Nayan Oza
Enrollment No :- 19012011102
Output 3 :
Input :-
import time
import enum
import queue
class Action(enum.Enum):
MoveDown = 1
MoveUp = 2
MoveLeft = 3
MoveRight = 4
NoAction = 5
class Node:
def __init__(self, position: [], parent=None,
action=Action.NoAction):
self.position = position
self.action = action
self.parent = parent
self.f = 0
self.h = 0
def __eq__(self, other):
return self.position == other.position
def lt(self, other):
return self.f < other.f
def __repr__(self):
return 'n'.join([str(self.action),
str(self.position[:3]),

3. Practical-4
3 | P a g e
Name:- Nayan Oza
Enrollment No :- 19012011102
str(self.position[3:6]),
str(self.position[6:])]).replace('[',
'').replace(']', '').replace('.', '').replace('0', '_')
def __h__(self, goal):
return sum([1 if self.position[i] != goal[i] else 0 for i in
range(9)])
def generateHeuristicValue(self, goal):
self.h = self.__h__(goal)
self.f = self.h
def possible_moves(self):
successors = []
i = self.position.index(0)
if i in [0, 1, 2, 3, 4, 5]:
new_board = self.position[:]
new_board[i], new_board[i + 3] = new_board[i + 3],
new_board[i]
successors.append(Node(new_board, self,
Action.MoveDown))
if i in [0, 1, 3, 4, 6, 7]:
new_board = self.position[:]
new_board[i], new_board[i + 1] = new_board[i + 1],
new_board[i]
successors.append(Node(new_board, self,
Action.MoveRight))
if i in [1, 2, 4, 5, 7, 8]:
new_board = self.position[:]
new_board[i], new_board[i - 1] = new_board[i - 1],
new_board[i]
successors.append(Node(new_board, self,
Action.MoveLeft))
if i in [3, 4, 5, 6, 7, 8]:
new_board = self.position[:]
new_board[i], new_board[i - 3] = new_board[i - 3],
new_board[i]
successors.append(Node(new_board, self, Action.MoveUp))
return successors
def best_first_search(initialValues, goalValues):
Open = []
closed = []
initial_node = Node(initialValues, None)
goal_node = Node(goalValues, None)

4. Practical-4
4 | P a g e
Name:- Nayan Oza
Enrollment No :- 19012011102
Open.append(initial_node)
while len(Open) > 0:
Open.sort(key=lambda x: x.h)
current_node = Open.pop(0)
closed.append(current_node)
if current_node == goal_node:
path = []
temp = current_node
while temp:
path.append(temp)
temp = temp.parent
return path[::-1]
allSuccessors = current_node.possible_moves()
for successor in allSuccessors:
if successor in closed:
continue
successor.generateHeuristicValue(goalValues)
if can_add_to_open(Open, successor) == True:
Open.append(successor)
return None
def can_add_to_open(Open, successor):
for node in Open:
if successor == node and successor.f >= node.f:
return False
return True
def main():
initial = [1, 2, 3, 0, 4, 6, 7, 5, 8]
# initial = [2, 8, 3, 1, 6, 4, 7, 0, 5]
# initial = [3, 0, 7, 2, 8, 1, 6, 4, 5]
goal = [1, 2, 3, 4, 5, 6, 7, 8, 0]
# goal = [1, 2, 3, 8, 0, 4, 7, 6, 5]
# goal = [1, 2, 3, 4, 5, 6, 7, 8, 0]
startTime = time.time()
path = best_first_search(initial, goal)
endTime = time.time()
diffBFSTime = endTime-startTime
print("")
for m in path:
print(m)
print()
print("nSteps to goal: {0}".format(len(path) - 1))
print("Execution Time= "+str(diffBFSTime*1000)+"ms")
print()

5. Practical-4
5 | P a g e
Name:- Nayan Oza
Enrollment No :- 19012011102
if __name__ == "__main__":
main()
Output :-

6. Practical-4
6 | P a g e
Name:- Nayan Oza
Enrollment No :- 19012011102

7. Practical-4
7 | P a g e
Name:- Nayan Oza
Enrollment No :- 19012011102