NAME – ARMAN KHAN ROLL – NO 13

Name:Arman Khan
Class:TYBScIT
Roll No: 13

Subject: Artificial Intelligence Practicals

Prac. No. TOPICS

A: DFS
1
B: BFS
2 Tower of Hanoi
A: Hill Climbing
3
B: Alpha-Beta Search
4 A-star Algorithm
A: Water Jug Problem (Manual)
5 B: WaterJug Problem (Automated) C:
Tic-Tac-Toe
6 8 Puzzle Problem
7 Card Deck Problem
A: Constraint Satisfaction Problem
8
B: Constraint Satisfaction Problem
9 Family Relations

Artificial Intelligence Lab Journal 2021-22

Practical 1A: Depth First Search Algorithm (10/08/2020)
AIM: Write a program to implement Depth First Search Algorithm.
CODE:

graph1 = {

'A':set(['B','C']),
'B':set(['A','D','E']),
'C':set(['A','F']),
'D':set(['B']),
'E':set(['B','F']),
'F':set(['C','E']),
}

def dfs(graph, node, visited):

if node not in visited:
visited.append(node)
for n in graph[node]:
dfs(graph,n, visited)
return visited

visited=dfs(graph1,'A',[])
print(visited)

OUTPUT:
Practical 1B: Breadth First Search Algorithm (17/08/2020)
AIM: Write a program to implement Breadth First Search Algorithm.

CODE:

graph12 = {
'A':set(['B','C']),
'B':set(['D','E']),
'C':set(['F']),
'D':set([]),
'E':set(['F']),
'F':set([]),

visited=[]
queue=[]
def Arman_bfs(visited,graph,node):

visited.append(node)

queue.append(node)
while queue:
s=queue.pop(0)
print(s,end=" ")

for neighbor in graph[s]:

if neighbor not in visited:

visited.append(neighbor)

queue.append(neighbor)

Arman_bfs(visited,graph12,'A')
OUTPUT:
Practical 2: Tower of Hanoi (24/08/2020)
AIM: Write a program to solve Tower of Hanoi problem.

CODE:

def TowerOfHanoi(n,source,auxiliary,destination):
if n==1:
print("Move disk 1 from source",source,"to destination",destination)
return

TowerOfHanoi(n-1,source,destination,auxiliary)
TowerOfHanoi(1,source,auxiliary,destination)
TowerOfHanoi(n-1,auxiliary,source,destination)

n=3
TowerOfHanoi(n,'A','B','C')

OUTPUT:
Practical 3A: Hill Climbing Problem (24/08/2020)
AIM: Write a program for hill climbing problem.

CODE:
import math

increment=0.1
startingPoint=[1,1]
point1=[1,5]
point2=[6,4]
point3=[5,2]
point4=[2,1]

def distance(x1,y1,x2,y2):
dist=math.pow(x2-x1,2)+ math.pow(y2-y1,2)
return dist

def sumOfDistances(x1,y1,px1,py1,px2,py2,px3,py3,px4,py4):
d1=distance(x1,y1,px1,py1)
d2=distance(x1,y1,px2,py2)
d3=distance(x1,y1,px3,py3)
d4=distance(x1,y1,px4,py4)

return d1+d2+d3+d4

def newDistance(x1,y1,point1,point2,point3,point4):
d1=[x1,y1]
d1temp=sumOfDistances(x1,y1,point1[0],point1[1],point2[0],point2[1],
point3[0],point3[1],point4[0],point4[1])
d1.append(d1temp)
return d1

minDistance=sumOfDistances(startingPoint[0],startingPoint[1],point1[0],point
1[1],
point2[0],point2[1],point3[0],point3[1],point4[0],point4[1])
flag=True

def newPoints(minimum,d1,d2,d3,d4):
if d1[2]==minimum:
 return[d1[0],d1[1]]
elif d2[2]==minimum:
 return[d2[0],d2[1]]
elif d3[2]==minimum:
return[d3[0],d3[1]]
elif d4[2]==minimum:
return[d4[0],d4[1]]
i=1
while flag:
d1=newDistance(startingPoint[0]+increment,startingPoint[1],point1,point2,p
oint3,point4)
d2=newDistance(startingPoint[0]-
increment,startingPoint[1],point1,point2,point3,point4)
d3=newDistance(startingPoint[0],startingPoint[1]+increment,point1,point2,p
oint3,point4)
d4=newDistance(startingPoint[0],startingPoint[1]-
increment,point1,point2,point3,point4)
print(i,'',round(startingPoint[0],2),round(startingPoint[1],2))
minimum=min(d1[2],d2[2],d3[2],d4[2])
if minimum<minDistance:
startingPoint=newPoints(minimum,d1,d2,d3,d4)
minDistance=minimum
#print i,'',round(startingPoint[0],2),round(startingPoint[1],2)
i+=1
else:
flag=False

OUTPUT:
Practical 3B: Alpha-Beta Search (10/11/2020)
AIM: Write a program to implement Alpha Beta Search

CODE:
MAX,MIN= 1000,-1000

#Returns optimal value for current player

#(intially called for toot and maximum)

def minimax(depth,nodeIndex,maximizingPlayer,values,alpha,beta):
#Terminating condition i.e leaf node is reached
if depth == 3:
return values[nodeIndex]
if maximizingPlayer:
best = MIN
#Recur for left and right children
for i in range(0,2):
val=minimax(depth+1,nodeIndex*2+i,False,values,alpha,beta)
best = max(best,val)
alpha=max(alpha,best) #alpha beta pruning
if beta<=alpha:
break
return best
else:
best=MAX
#Recur for left and right children
for i in range(0,2):
val=minimax(depth+1,nodeIndex*2+i,True,values,alpha,beta)
best=min(best,val)
beta=min(beta,best)
#alpha beta pruning
if beta<=alpha:
break
return best

#Driver code
values=[3,5,6,9,1,2,0,-1
print("The optimal value is:",minimax(0,0,True,values,MIN,MAX))

OUTPUT:
Practical 4: A-star Algorithm (31/08/2020)
AIM: Write a program to implement A-star Algorithm.

CODE:

from simpleai.search import SearchProblem, astar

GOAL='HELLO WORLD'
class HelloProblem(SearchProblem):
def actions(self,state):
if len(state)<len(GOAL):
return list(' ABCDEFGHIJKLMNOPQRSTUVWXYZ')
else:
return []

def result(self,state,action):
return state + action

def is_goal(self,state):
return state == GOAL

def heuristic(self,state):
#how far are we from the goal?
wrong=sum([1 if state[i] != GOAL[i] else 0
for i in range(len(state))])
missing = len(GOAL) - len(state)
return wrong + missing

problem = HelloProblem(initial_state='')
result=astar(problem)
print(result.state)
print(result.path())
OUTPUT:
Practical 5A: Water Jug Problem (14/09/2020)
AIM: Write a program to solve Water Jug Problem.

A) Manual

program: CODE:

x=0
y=0
m=4
n=3
print("Initial state = (0,0)")
print ("Capacities = (4,3)")
print("Goal state = (2,y)")
while x!=2:
r=int (input("Enter rule : "))
if(r==1):
x=m
elif (r==2):
y= n
elif (r==3):
x= 0
elif (r==4):
y= 0
elif (r==5):
t = n-y
y= n
x -= t
elif (r==6):
t = m-x
x=m
y -= t
elif (r==7):
y += x
x=0
elif (r==8):
x += y
y=0
print (x,y)
OUTPUT:
Practical 5B: Water Jug Problem (14/09/2020)
B) Automated Program:

CODE:

#This function is used to initialize the

# Dictionary elements with a default value.
from collections import defaultdict

#jug1 and jug2 contain the value

# for max capacity in respective jugs
# and aim is the amount of water to be measured
jug1,jug2,aim = 4,3,2

#Initialize the dictionary with

#default value as false.
visited = defaultdict(lambda: False)

def waterJugSolver(amt1,amt2):

if(amt1==aim and amt2==0) or (amt2==aim and amt1==0):

print(amt1,amt2)
return True

#Checks if we have already visited the

#combination or not. If not, then it proceeds further.
if visited[(amt1,amt2)]==False:
print(amt1,amt2)

visited[(amt1,amt2)]=True

return (waterJugSolver(0,amt2) or
waterJugSolver(amt1,0) or
waterJugSolver(jug1,amt2) or
waterJugSolver(amt1,jug2) or
waterJugSolver(amt1+min(amt2, (jug1-amt1)),
amt2-min(amt2,(jug1-amt1)))or
waterJugSolver(amt1+min(amt1, (jug2-amt2)),
amt2+min(amt1,(jug2-amt2))))
else:
return False
print("Steps: ")

waterJugSolver(0,0)

OUTPUT:
Practical 5C: Tic-Tac-Toe Game (09/11/2020)
AIM: Design the simulation of tic-tac-toe game using min-max
algorithm

CODE:

import os
import time

board = [' ',' ',' ',' ',' ',' ',' ',' ',' ',' ']
player = 1
win = 1
draw = -1
running = 0
stop = 1
game = running
mark = 'X'

def DrawBoard():
print(" %c| %c| %c " % (board[1],board[2],board[3]))
print(" | | ")
print(" %c| %c| %c " % (board[4],board[5],board[6]))
print(" | | ")
print(" %c| %c| %c " % (board[7],board[8],board[9]))
print(" | | ")

def CheckPosition(x):
if(board[x]==' '):
return True
else:
return False

def CheckWin():
global game
#Horizontal Winning Conditions
if(board[1]==board[2] and board[1]==board[3] and board[1]!=' '):
game = win
elif(board[4]==board[5] and board[4]==board[6] and board[4]!=' '):
game = win
elif(board[7]==board[8] and board[7]==board[9] and board[7]!=' '):
game = win
 #Vertical Winning Conditions
elif(board[1]==board[4] and board[1]==board[7] and board[1]!=' '):
game = win
elif(board[2]==board[5] and board[2]==board[8] and board[2]!=' '):
game = win
elif(board[3]==board[6] and board[3]==board[9] and board[3]!=' '):
game = win

#Diagonal Winning Conditions

elif(board[1]==board[5] and board[1]==board[9] and board[1]!=' '):
game = win
elif(board[3]==board[5] and board[3]==board[7] and board[3]!=' '):
game = win

#Draw Condition
elif(board[1]!=' ' and board[2]!=' ' and board[3]!=' ' and board[4]!=' ' and
board[5]!=' ' and board[6]!=' ' and
board[7]!=' ' and board[8]!=' ' and board[9]!=' '):
game = draw
else:
game = running

print("TIC-TAC-TOE Game")
print("Player 1[X] Player 2[O]\n")
print()
print("Please wait...")

time.sleep(1)

while(game == running):
os.system('cls')
DrawBoard() if(player
%2 !=0):
print("Player 1's chance")
mark = 'X'
else:
print("Player 2's chance")
mark = 'O'

choice = int(input("Enter position between 1 and 9 :"))

if(CheckPosition(choice)):
 board[choice]=mark
player+=1
CheckWin()

os.system('cls')
DrawBoard()
if(game==draw):
print("Game Drawn")
elif(game==win):
player-=1
if(player%2!=0):
print("Player 1 wins!")
else:
print("Player 2 wins!")

OUTPUT:
Player l's chance

2's chance
Enter position between 1 and 9 :Z

Player l's chance

Enter position between 1 and 9 !3

Player 2's chance

Enter position between 1 and 9 :7
Practical 6: 8 Puzzle Problem (05/10/2020)
AIM: Design an application to simulate number puzzle problem.
game using min-max algorithm

CODE:

#from future import print_function

#from simpleai.search.viewers import WebViewer
from simpleai.search import astar, SearchProblem

GOAL = '''1-2-3
4-5-6
7-8-e'''

INITIAL = '''4-1-2
7-e-3
8-5-6'''

def list_to_string(list_):
return '\n'.join(['-'.join(row) for row in list_])
def string_to_list(string_):
return [row.split('-') for row in string_.split('\n')]
def find_location(rows, element_to_find):
'''Find the location of a piece in the puzzle.
Returns a tuple:row,column'''
for ir, row in enumerate(rows):
for ic,element in enumerate(row):
if element == element_to_find:
return ir,ic

goal_positions = {}
rows_goal = string_to_list(GOAL)
for number in '12345678e':
goal_positions[number] = find_location(rows_goal, number)

class EightPuzzleProblem(SearchProblem):
def actions(self,state):
'''Returns a list of the pieces we can move to the empty space.'''
rows = string_to_list(state)
row_e,col_e = find_location(rows,'e')
actions = []
 if row_e > 0:
actions.append(rows[row_e - 1] [col_e])
if row_e < 2:

actions.append(rows[row_e + 1] [col_e])
if col_e > 0:
actions.append(rows[row_e][col_e - 1])
if col_e < 2:
actions.append(rows[row_e] [col_e + 1])
return actions
print(actions)

def result(Self,state,action):
'''Return the resulting state after moving a piece to
the empty space.
(the "action" parameter contains the piece to move)'''
rows = string_to_list(state)
row_e,col_e = find_location(rows,'e')
row_n,col_n = find_location(rows,action)
rows[row_e][col_e], rows[row_n][col_n] = rows[row_n][col_n],
rows[row_e][col_e]
return list_to_string(rows)

def is_goal(self,state):

return state ==GOAL

def cost(self,state1,action,state2):
return 1

def heuristic(self,state):
'''Returns an *estimation* of the distance froma state to the goal.
We are using the manhattan distance.'''
rows=string_to_list(state)
distance=0
for number in '12345678e':
row_n,col_n = find_location(rows,number)
row_n_goal,col_n_goal = goal_positions[number]
distance += abs(row_n - row_n_goal) + abs(col_n - col_n_goal)
return distance
result = astar(EightPuzzleProblem(INITIAL))
for action, state in result.path():
print('Move Number :' ,action)
print(state)

OUTPUT:
Practical 7: Card Deck Problem (19/10/2020)
AIM: Write a program to shuffle deck of cards.

CODE:
import itertools, random
# make a deck of cards
deck = list(itertools.product(range(1,14),['Spade','Heart','Diamond','Club']))
print(deck)
#shuffle the cards
random.shuffle(deck)
#draw five cards
print ("You got :")
for i in range(4):
print(deck[i][0], "of" , deck[i][1])

OUTPUT:
Practical 8A: Constraint Satisfaction Problem
(02/11/2020)
AIM: Write a program for Constraint Satisfaction problem.

CODE:

from simpleai.search import CspProblem, backtrack

variables = ('A','B','C')
domains ={ 'A' : [1,2,3], 'B' : [1,3], 'C' : [1,2],}

def const_different(variables, values):

return len(values) == len(set(values))

def const_one_bigger_other(variables, values):

return values[0] > values[1]

#A constraint that expects two variables to be one odd and the other even,
#No matter which one is which type

def const_one_odd_one_even(variables, values):

if values[0] % 2 == 0:
return values[1] % 2 == 1 #first even, expect second to be odd
else:
return values[1] % 2 == 0 #first odd, expect second to be even

constraints = [(('A','B','C'),const_different),
(('A','C'), const_one_bigger_other),
(('A','C'), const_one_odd_one_even),]

my_problem = CspProblem(variables, domains, constraints)

print(backtrack(my_problem))
OUTPUT:
Practical 8B: Constraint Satisfaction Problem – Map
coloring Problem (02/11/2020)
CODE:
from simpleai.search import CspProblem, backtrack, min_conflicts,
MOST_CONSTRAINED_VARIABLE, LEAST_CONSTRAINING_VALUE

variables = ('WA', 'NT', 'SA', 'Q', 'NSW', 'V', 'T')

domains = dict((v, ['red', 'green', 'blue']) for v in variables)

def const_different(variables, values):

return values[0] != values[1]

constraints = [(('WA', 'NT'),const_different),

(('WA', 'SA'),const_different),
(('SA', 'NT'),const_different),
(('SA', 'Q'),const_different),
(('NT', 'Q'),const_different),
(('SA', 'NSW'),const_different),
(('Q', 'NSW'),const_different),
(('SA', 'V'),const_different),
(('NSW', 'V'),const_different)]

my_problem = CspProblem(variables, domains, constraints)

print(backtrack(my_problem))
print(backtrack(my_problem, variable_heuristic=MOST_CONSTRAINED_VARIA
BLE))
print(backtrack(my_problem, value_heuristic=LEAST_CONSTRAINING_VALUE))
print(backtrack(my_problem, variable_heuristic=MOST_CONSTRAINED_VARIA
BLE,
value_heuristic=LEAST_CONSTRAINING_VALUE))
print(min_conflicts(my_problem))
OUTPUT:
Practical 9: Family relations– Prolog program (19/10/2020)
AIM: Write a program in prolog to demonstrate family relations. It
contains 3 predicates: male, female, parent. Make rules for the
family relations grandfather, grandmother, grandparent, uncle and
aunt.

CODE:
male(randhir).
male(taimur).
male(sanjay).
female(babita).
female(karishma).
female(kareena).
female(samaira).
parent(babita,kareena).
parent(randhir,kareena).
parent(babita,karishma).
parent(kareena,taimur).
parent(karishma,samaira).
parent(sanjay,samaira).
husband(X,Y):-parent(X,Z),parent(Y,Z),male(X),female(Y),female(Z).
sister(X,Y):-parent(Z,X),parent(Z,Y),female(X),female(Y).
uncle(X,Z):-husband(X,Y),sister(Y,B),parent(B,Z),male(X).
aunt(X,Y):-sister(X,Z),parent(Z,Y),female(X).
grandmother(X,Y):-parent(X,Z),parent(Z,Y),female(X).
grandfather(X,Y):-parent(X,Z),parent(Z,Y),male(X).
grandparent(X,Y):-parent(X,Z),parent(Z,Y).
OUTPUT :