0% found this document useful (0 votes)
74 views20 pages

Master of Computer Application (5 Sem) : A Lab Manual ON

1) The document is a lab manual for an Artificial Intelligence course submitted to Gujarat Technological University in fulfillment of a Master's degree. It contains the internal guide's signature certifying the original work of the student. 2) The manual provides Python programs and code snippets for problems related to AI including calculating factorials recursively, solving the Tower of Hanoi problem, implementing depth-first and breadth-first search algorithms, solving the water jug problem, and implementing the 8-puzzle problem using a search algorithm. It provides sample inputs and outputs for each program.
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOC, PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
74 views20 pages

Master of Computer Application (5 Sem) : A Lab Manual ON

1) The document is a lab manual for an Artificial Intelligence course submitted to Gujarat Technological University in fulfillment of a Master's degree. It contains the internal guide's signature certifying the original work of the student. 2) The manual provides Python programs and code snippets for problems related to AI including calculating factorials recursively, solving the Tower of Hanoi problem, implementing depth-first and breadth-first search algorithms, solving the water jug problem, and implementing the 8-puzzle problem using a search algorithm. It provides sample inputs and outputs for each program.
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOC, PDF, TXT or read online on Scribd
You are on page 1/ 20

A

LAB MANUAL
ON
Artificial Intelligence
In fulfillment towards the award of the degree of
Master of Computer Application(5th SEM)
Under
GUJARAT TECHNOLOGICAL UNIVERSITY, AHMEDABAD.
2017-2018

INTERNAL GUIDE : SUBMITTED BY:


Prof.Upasana Mehta Name:Lad Pinkalkumar K.
Enrollment No:175043693018
CERTIFICATE

This is to certify that the “ AI LAB Manual “ was prepared by

Name: Enrollment No:


Lad Pinkalkumar K. 175043693018

under my guidance for fulfillment of the degree of Master of Computer Applications


of Gujarat Technological University, Ahmedabad during the academic year 2016-17.
I certify that this manual is his/her original work and not copied from other sources.

______________________
Internal Guide Signature
1)Write a program to find the factorial of given number.

def recur_factorial(n):
"""Function to return the factorial
of a number using recursion"""
if n == 1:
return n
else:
return n*recur_factorial(n-1)

num = int(input("Enter a number: "))


if num < 0:
print("Sorry, factorial does not exist for negative numbers")
elif num == 0:
print("The factorial of 0 is 1")
else:
print("The factorial of",num,"is",recur_factorial(num))

*****************************Output********************************
2)Write a code in python to solve Tower of Hanoi Problem. Write a function to input no of
disk.

def TowerOfHenoi(n,source,dest,aux):

if(n==1):

print ("Move Disk 1 From",source,"To",dest)

return

else:

TowerOfHenoi(n-1,source,aux,dest)

print("Move Disk",n,"From",source,"To",dest)

TowerOfHenoi(n-1,aux,dest,source)

n=int(input("Enter The Disk ="))

TowerOfHenoi(n,'A','C','B')
************************************Output***********************************
3)Write a program to implement Depth First Search(DFS).

def DFS(graph,start):

open, close =[start],[]

##close=[]

while open:

node=open.pop()

if node in close:

continue

close.append(node)

for n in graph[node]:

open.append(n)

return close

graph = {1: [2, 3], 2: [4, 5],

3: [5], 4: [6], 5: [6],

6: [7], 7: []}
print(DFS(graph, 1))

# [1, 3, 5, 6, 7, 2, 4]

*************************************Output************************************
4)Write a program to implement Best First Search(BFS).

def BFS(graph,start):

open, close =[start],[]

##close=[]

while open:

node=open.pop()

if node in close:

continue

close.append(node)

for n in graph[node]:

open.insert(0,n)

return close

graph = {1: [2, 3], 2: [4, 5],

3: [5], 4: [6], 5: [6],

6: [7], 7: []}
print(BFS(graph, 1))

# [1, 2, 3, 4, 5, 6, 7]

**********************************Output****************************************
5)Write a program to implement water jug problem.

capacity=(4,3)

x=capacity[0]

y=capacity[1]

ans=[]

memory={}

def waterjug(stat):

a=stat[0]

b=stat[1]

if(a==2 and b==0):

print("Goal is achived")

ans.append(stat)

return True

if((a,b) in memory):

return False

ans.append(stat)

memory[(a,b)]=1
if(b>0):

if(a+b<=x):

if(waterjug((a+b,0))):

return True

else:

if(waterjug((x,b-(x-a)))):

return True

elif(b==0):

if(waterjug((a,y))):

return True

if(a>0):

if((a+b)<=y):

if(waterjug((0,a+b))):

return True

elif(a+b>=x):

if(waterjug((a-(y-b),y))):

return True
elif(a==x):

if(waterjug((0,b))):

return True

elif(a==0):

if(waterjug((x,b))):

return True

return False

init=(0,0)

waterjug(init)

for i in ans:

print (i)

*********************************Output**************************************
6)WAP to implement 8-puzzle problem using any of algorithm
import os

os.system("clear")

def printstat(stat):

print(stat[0],stat[1],stat[2])

print(stat[3],stat[4],stat[5])

print(stat[6],stat[7],stat[8])

print()

def move_up(stat):

new_node=stat[:]

print(new_node)

index=new_node.index(0)

print(index)

if index not in [0,1,2]:

temp=new_node[index-3]

new_node[index-3]=new_node[index]

new_node[index]=temp

return new_node
else:

return None

def move_down(stat):

new_node=stat[:]

index=new_node.index(0)

if index not in [6,7,8]:

temp=new_node[index+3]

new_node[index+3]=new_node[index]

new_node[index]=temp

return new_node

else:

return None

def move_left(stat):

new_node=stat[:]

index=new_node.index(0)

if index not in [0,3,6]:

temp=new_node[index-1]
new_node[index-1]=new_node[index]

new_node[index]=temp

return new_node

else:

return None

def move_right(stat):

new_node=stat[:]

index=new_node.index(0)

if index not in [2,5,8]:

temp=new_node[index+1]

new_node[index+1]=new_node[index]

new_node[index]=temp

return new_node

else:

return None

class Node :

def __init__(self,stat,parent,operator,depth):
self.stat=stat

self.parent=parent

self.operator=operator

self.depth=depth

def create_node(stat,parent,operator,depth):

return Node(stat,parent,operator,depth)

def expand_node(node):

expanded_node=[]

expanded_node.append(create_node(move_up(node.stat),node,"U",node.depth+1))

expanded_node.append(create_node(move_down(node.stat),node,"D",node.depth+1))

expanded_node.append(create_node(move_left(node.stat),node,"L",node.depth+1))

expanded_node.append(create_node(move_right(node.stat),node,"R",node.depth+1))

expanded_node=[node for node in expanded_node if node.stat!=None]

return expanded_node

def bfs(stat,goal):

nodes=[]

visited=[]
nodes.append(create_node(stat,None,None,0))

visited.append(create_node(stat,None,None,0))

while True:

temp=[]

if(len(nodes)==0):

return None

node=nodes.pop(0)

if(node.stat==goal):

move=[]

tmp=node

while True:

move.append(tmp.operator)

if(tmp.depth<=1):

break

tmp=tmp.parent

return move

temp.extend(expand_node(node))

for tempnode in temp:


if(tempnode not in visited):

nodes.insert(0,tempnode)

visited.append(tempnode)

def main():

init_stat=[1,2,3,8,4,0,7,6,5]

goal_stat=[1,2,3,8,0,4,7,6,5]

print("init stat")

printstat(init_stat)

move=bfs(init_stat,goal_stat)

print (move[::-1])

print("goal stat")

printstat(goal_stat)

main()

***********************************Output************************************

You might also like