INDEX

Expt No List of Programs PageNos.

1 a) Write a program to print the multiplication table for the given number
b) Write a program to find factorial of a number
c) Write a program to check whether the given number is prime or not
a) Write program to implement Simple Calculator program
2 b) Write a program to generate Calendar for the given month and year
c) Write a program to Illustrate Different Set Operations

3 Write a program to implement simple Chat bot

a) Write a program to remove punctuations from the given string

4 b) Write a program to sort the sentence in alphabetical order

Write a program to Implement of Towers of Hanoi Problem.

5

Write a Program to Implement Breadth First Search.

6

7 Write a Program to Implement Depth First Search.

Write a program to implement Hill Climbing Algorithm

8

Write a program to implement A* Algorithm.

9

10 Write a program to implement Tic-Tac-Toe game.

Write a program to implement Water Jug Problem

11

Artificial Intelligence Manual

PROGRAM-1(A)

1A) Aim: Write a program to print the multiplication table for the given number

Program:

# Python program to find the multiplication table (from 1 to 10) of a number input by the
user
# Get input from the user

num = int(input("Display multiplication table of? "))

# use for loop to iterate 10 times

for i in range(1,11):
print(num,'x',i,'=',num*i)

Output:
Display multiplication table of?
55x1=5
5 x 2 = 10
5 x 3 = 15
5 x 4 = 20
5 x 5 = 25
5 x 6 = 30
5 x 7 = 35
5 x 8 = 40
5 x 9 = 45
5 x 10 = 50

PROGRAM-1(B)

1B) Aim: Write a program to find factorial of the given number

Program:
def recur_factorial(n):

if n == 1:
return n else:
return n*recur_factorial(n-1)

Artificial Intelligence Manual

num = int(input("Enter a number: ")) # check is the number is negative
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:
Enter a number: 5

The factorial of 5 is 120

PROGRAM-1(C)

1C) Aim: Write a program to check whether the given number is prime or not?

Program:
# Python program to check if the input number is prime or not

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

# prime numbers are greater than 1 if num > 1:

rem=1
for i in range(2,num):
rem=num%i

if rem == 0:

break

if rem == 0:
print(num,"is not a prime number")
else:
print(num,"is a prime number")
else:
print(num,"is not a prime number")

Output:

Enter a number: 5
5 is a prime number

Artificial Intelligence Manual

PROGRAM-2(A)

2A) Write a program to implement Simple Calculator program

Program:

# Program make a simple calculator that can add, subtract, multiply and divide using

functions

# define functions

def add(x, y):

"""This function adds two numbers"""

return x + y

def subtract(x, y):

""This function subtracts two numbers"""

return x - y

def multiply(x, y):

"""This function multiplies two numbers"""

return x * y

def divide(x, y):

"""This function divides two numbers"""

return x / y

# take input from the

user print("Select
operation.")
print("1.Add")
print("2.Subtract")
print("3.Multiply")
print("4.Divide")
choice = input("Enter choice(1/2/3/4):")
num1 = int(input("Enter first number: "))

Artificial Intelligence Manual

 num2 = int(input("Enter second number: "))
if choice == '1':
print(num1,"+",num2,"=", add(num1,num2))
elif choice == '2':
print(num1,"-",num2,"=", subtract(num1,num2))
elif choice == '3':
print(num1,"*",num2,"=", multiply(num1,num2))
elif choice == '4':
print(num1,"/",num2,"=", divide(num1,num2))
else:
print("Invalid input")

Output:

Select operation.

1.Add

2. Subtract

3.Multiply

4.Divide

Enter choice(1/2/3/4):1

Enter first number: 21

Enter second number: 22

21 + 22 = 43

PROGRAM-2(B)

2B) Aim: Write a program to generate Calendar for the given month and year

Program:

# Python program to display calendar of given month of the year # import

module
import calendar
yy = 2014
mm = 11

Artificial Intelligence Manual

 # To ask month and year from the user# Python program to display calendar of given
month of the year
# import module import
calendar
yy = 2014
mm = 11

# To ask month and year from the

user # yy = int(input("Enter year: "))
# mm = int(input("Enter month: "))
# display the calendar
print(calendar.month(yy, mm))
# yy = int(input("Enter year: "))

# mm = int(input("Enter month: "))

# display the calendar print(calendar.month(yy, mm))

Output: November 2014

Mo Tu We Th Fr Sa Su

1 2

3 4 5 6 7 8 9

10 11 12 13 14 15 16

17 18 19 20 21 22 23
24 25 26 27 28 29 30

PROGRAM-2(C)

2C) Aim: Write a program to Illustrate Different Set Operations?

Program:

# Program to perform different set operations like in

mathematics # define three sets

E = {0, 2, 4, 6, 8};
N = {1, 2, 3, 4, 5};
# set union

Artificial Intelligence Manual

 print("Union of E and N is",E | N)
# set intersection
print("Intersection of E and N is",E & N)

# set difference
print("Difference of E and N is",E - N)

# set symmetric difference

print("Symmetric difference of E and N is",E ^ N)

Output:

Union of E and N is {0, 1, 2, 3, 4, 5, 6,

8} Intersection of E and N is {2, 4}
Difference of E and N is {0, 8, 6}
Symmetric difference of E and N is {0, 1, 3, 5, 6, 8}

Artificial Intelligence Manual

 PROGRAM-3

Aim:

Write a program to implement simple Chat bot

Program:

print("Simple Question and Answering Program")

print("=====================================")
print(" You may ask any one of these questions")
print("Hi")
print("How are you?")
print("Are you working?")
print("What is your name?")
print("what did you do
yesterday?") print("Quit")
while True:
question = input("Enter one question from above list:")
question = question.lower()
if question in ['hi']:
print("Hello")
elif question in ['how are you?','how do you do?']:
print("I am fine")
elif question in ['are you working?','are you doing any job?']:
print("yes. I'am working in MRCET")
elif question in ['what is your name?']:
print("My name is Emilia")
name=input("Enter your name?")
print("Nice name and Nice meeting you",name)
elif question in ['what did you do yesterday?']:
print("I saw Bahubali 5 times")

Artificial Intelligence Manual

 elif question in ['quit']:
break

else:
print("I don't understand what you said")
Output:
Simple Question and Answering Program
==============================
You may ask any one of these
questions Hi
How are you?
Are you
working?
What is your name?
what did you do
yesterday? Quit
Enter one question from above list:hi
Hello
Enter one question from above list:how are
you? I am fine
Enter one question from above list:are you working?
yes. I'am working in MRCET
Enter one question from above list:what is your name?
My name is Emilia
Enter your name?sachin
Nice name and Nice meeting you sachin
Enter one question from above list:quit

Artificial Intelligence Manual

 PROGRAM-4(A)

Aim: Write a program to remove punctuations from the given string

Program:

# define punctuation
punctuations = '''!()-[]{};:'"\,<>./?@#$%^&*_~'''
my_str = "Hello!!!, he said ---and went."
# To take input from the user
# my_str = input("Enter a string: ")
# remove punctuation from the string
no_punct = ""
for char in my_str:
if char not in punctuations:
no_punct = no_punct + char
# display the unpunctuated string
print(no_punct)

Output:
Hello he said and went

PROGRAM-4(B)

Aim: 4(B).Write a program to sort the sentence in alphabetical order

Program:

# Program to sort alphabetically the words form a string provided by the

user # change this value for a different result
my_str = "Hello this Is an Example With cased letters"
# uncomment to take input from the user

Artificial Intelligence Manual

 #my_str = input("Enter a string: ")
# breakdown the string into a list of words

words = my_str.split()
#print(words)
# sort the list
words.sort()
# display the sorted words
print("The sorted words are:")
for word in words:
print(word)
Output:
The sorted words are:
Example
Hello
Is
With
an
cased
letter
s this

Artificial Intelligence Manual

 PROGRAM-5

Aim: Write a Program to Implement of Towers of Hanoi Problem.

Program:
# Recursive Python function to solve tower of hanoi
def TowerOfHanoi(n , from_rod, to_rod, aux_rod):
if n == 0:
return
TowerOfHanoi(n-1, from_rod, aux_rod, to_rod)

print("Move disk",n,"from rod",from_rod,"to rod",to_rod)

TowerOfHanoi(n-1, aux_rod, to_rod, from_rod)
# Driver code
n=4
TowerOfHanoi(n, 'A', 'C', 'B') # A, C, B are the name of rods
Output:
Move disk 1 from rod A to rod B
Move disk 2 from rod A to rod C
Move disk 1 from rod B to rod C
Move disk 3 from rod A to rod B
Move disk 1 from rod C to rod A
Move disk 2 from rod C to rod B
Move disk 1 from rod A to rod B
Move disk 4 from rod A to rod C
Move disk 1 from rod B to rod C
Move disk 2 from rod B to rod A
Move disk 1 from rod C to rod A
Move disk 3 from rod B to rod C
Move disk 1 from rod A to rod B
Move disk 2 from rod A to rod C
Move disk 1 from rod B to rod C

Artificial Intelligence Manual

 PROGRAM-6

Aim:

Write a Program to Implement Breadth First Search.

Program:

graph = {
'5' : ['3','7'],
'3' : ['2', '4'],
'7' : ['8'],
'2' : [],
'4' : ['8'],
'8' : []
}

visited = [] # List for visited

nodes. queue = [] #Initialize a
queue

def bfs(visited, graph, node): #function for BFS

visited.append(node)
queue.append(node)

while queue: # Creating loop to visit each

node m = queue.pop(0)
print (m, end = " ")

for neighbour in graph[m]:

if neighbour not in visited:
visited.append(neighbour)
queue.append(neighbour)

# Driver Code
print("Following is the Breadth-First
Search") bfs(visited, graph, '5') #
function calling

Output:
Following is the Breadth-First Search
537248

Artificial Intelligence Manual

 PROGRAM-7

Aim:

Write a Program to Implement Depth First Search.

Program:
graph = {
'5' : ['3','7'],
'3' : ['2', '4'],
'7' : ['8'],
'2' : [],
'4' : ['8'],
'8' : []
}

visited = set() # Set to keep track of visited nodes of graph.

def dfs(visited, graph, node):

#function for dfs if node not in

visited: print (node)
visited.add(node)
for neighbour in graph[node]:
dfs(visited, graph, neighbour)

# Driver Code

print("Following is the Depth-First Search")

dfs(visited, graph, '5')

Output:
Following is the Depth-First Search
5
3
2
4

Artificial Intelligence Manual

 PROGRAM-8

Aim:

Write a program to implement Hill Climbing Algorithm

Program:

import random

def randomSolution(tsp):

cities = list(range(len(tsp)))

solution = []

for i in range(len(tsp)):

randomCity = cities[random.randint(0, len(cities) - 1)]

solution.append(randomCity)

cities.remove(randomCity)

return solution

def routeLength(tsp, solution):

routeLength = 0

for i in range(len(solution)):

routeLength += tsp[solution[i - 1]][solution[i]]

return routeLength

def getNeighbours(solution):

neighbours = []

for i in range(len(solution)):

for j in range(i + 1, len(solution)):

Artificial Intelligence Manual

 neighbour = solution.copy()

neighbour[i] = solution[j]

neighbour[j] = solution[i]

neighbours.append(neighbour)

return neighbours

def getBestNeighbour(tsp, neighbours):

bestRouteLength = routeLength(tsp, neighbours[0])

bestNeighbour = neighbours[0]

for neighbour in neighbours:

currentRouteLength = routeLength(tsp, neighbour)

if currentRouteLength < bestRouteLength:

bestRouteLength =

currentRouteLength bestNeighbour =

neighbour

return bestNeighbour, bestRouteLength

def hillClimbing(tsp):

currentSolution = randomSolution(tsp)

currentRouteLength = routeLength(tsp, currentSolution)

neighbours = getNeighbours(currentSolution)

bestNeighbour, bestNeighbourRouteLength = getBestNeighbour(tsp, neighbours)

while bestNeighbourRouteLength < currentRouteLength:

currentSolution = bestNeighbour

currentRouteLength = bestNeighbourRouteLength
Artificial Intelligence Manual
 neighbours = getNeighbours(currentSolution)

bestNeighbour, bestNeighbourRouteLength = getBestNeighbour(tsp, neighbours)

return currentSolution, currentRouteLength

def main():

tsp = [

[0, 400, 500, 300],

[400, 0, 300, 500],

[500, 300, 0, 400],

[300, 500, 400, 0]

print(hillClimbing(tsp))

if name == " main ":

main()

Output:

([1, 0, 3, 2], 1400)

 PROGRAM-9

Aim:

Write a program to implement A* Algorithm

Program:
from collections import deque

class Graph:
def init (self, adjac_lis):
self.adjac_lis = adjac_lis

def get_neighbors(self, v):

return self.adjac_lis[v]

# This is heuristic function which is having equal values for all nodes
def h(self, n):
H={
'A': 1,
'B': 1,
'C': 1,
'D': 1
}
return H[n]

def a_star_algorithm(self, start, stop):

# In this open_lst is a lisy of nodes which have been visited, but who's
# neighbours haven't all been always inspected, It starts off with the
start #node
# And closed_lst is a list of nodes which have been visited
# and who's neighbors have been always inspected
open_lst = set([start])
closed_lst = set([])

# poo has present distances from start to all other

Artificial Intelligence Manual
nodes # the default value is +infinity
poo = {}
poo[start] = 0

# par contains an adjac mapping of all nodes

par = {}
par[start] = start

while len(open_lst) > 0:

n = None

# it will find a node with the lowest value of f() -

for v in open_lst:
if n == None or poo[v] + self.h(v) < poo[n] + self.h(n): n
= v;

if n == None:
print('Path does not exist!')
return None

# if the current node is the stop

# then we start again from start if n == stop:
reconst_path = []

while par[n] != n:
reconst_path.append(n) n =
par[n]
reconst_path.append(start)

reconst_path.reverse()

print('Path found: {}'.format(reconst_path))

return reconst_path

# for all the neighbors of the current node do

for (m, weight) in self.get_neighbors(n):
# if the current node is not presentin both open_lst and
closed_lst
# add it to open_lst and note n as it's par
if m not in open_lst and m not in closed_lst:
open_lst.add(m)
par[m] = n
poo[m] = poo[n] + weight

# otherwise, check if it's quicker to first visit n, then m

Artificial Intelligence Manual
# and if it is, update par data and poo data
# and if the node was in the closed_lst, move it to open_lst
else:
if poo[m] > poo[n] + weight:
poo[m] = poo[n] + weight
par[m] = n

if m in closed_lst:
closed_lst.remove(m)
open_lst.add(m)

Artificial Intelligence Manual

 # remove n from the open_lst, and add it to
closed_lst # because all of his neighbors were
inspected open_lst.remove(n)
closed_lst.add(n)

print('Path does not exist!')

return None
adjac_lis = {
'A': [('B', 1), ('C', 3), ('D', 7)],
'B': [('D', 5)],
'C': [('D', 12)]
}
graph1 = Graph(adjac_lis)
graph1.a_star_algorithm('A', 'D')

Output:

Path found: ['A', 'B', 'D']

Artificial Intelligence Manual

 PROGRAM-10

Aim:

Write a program to implement Tic-Tac-Toe game.

Program:
import os
import time

board = [' ',' ',' ',' ',' ',' ',' ',' ',' ',' ']
player = 1

########win Flags##########
Win = 1
Draw = -1
Running = 0
Stop = 1
###########################
Game = Running
Mark = 'X'

#This Function Draws Game Board

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(" | | ")

#This Function Checks position is empty or not

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

#This Function Checks player has won or not

def CheckWin():
global Game
#Horizontal winning condition
if(board[1] == board[2] and board[2] == board[3] and board[1] != ' '):
Game = Win
elif(board[4] == board[5] and board[5] == board[6] and board[4] != ' '):
Game = Win
elif(board[7] == board[8] and board[8] == board[9] and board[7] != ' '):
Game = Win

#Vertical Winning Condition

elif(board[1] == board[4] and board[4] == board[7] and board[1] != ' '):
Game = Win
elif(board[2] == board[5] and board[5] == board[8] and board[2] != ' '):
Game = Win
elif(board[3] == board[6] and board[6] == board[9] and board[3] != ' '):
Game=Win
#Diagonal Winning Condition
elif(board[1] == board[5] and board[5] == board[9] and board[5] != ' '):
Game = Win
elif(board[3] == board[5] and board[5] == board[7] and board[5] != ' '):
Game=Win
#Match Tie or 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 Designed By Sourabh Somani")
print("Player 1 [X] --- Player 2 [O]\n")
print()
print()
print("Please Wait...")
time.sleep(3)
while(Game == Running):
os.system('cls')
DrawBoard()
if(player % 2 != 0):
print("Player 1's chance")

Artificial Intelligence Manual

 Mark =
'X' else:
print("Player 2's chance")
Mark = 'O'
choice = int(input("Enter the position between [1-9] where you want to mark :
"))
if(CheckPosition(choice)):
board[choice] = Mark
player+=1 CheckWin()

os.system('cls')
DrawBoard()
if(Game==Draw):
print("Game Draw")
elif(Game==Win):
player-=1
if(player%2!=0):
print("Player 1 Won")
else:
print("Player 2 Won")

Output:

[[0 0 0]
[0 0 0]
[0 0 0]]
Board after 1
move [[0 0 0]
[0 1 0]
[0 0 0]]
Board after 2
move [[0 0 0]
[0 1 0]
[0 2 0]]
Board after 3
move [[0 0 0]
[0 1 0]
[1 2 0]]
Board after 4
move [[0 0 2]
[0 1 0]
[1 2 0]]
Board after 5
move [[0 0 2]
Artificial Intelligence Manual
[0 1 0]
[1 2 1]]
Board after 6
move [[0 0 2]
[0 1 2]
[1 2 1]]
Board after 7
move [[0 0 2]
[1 1 2]
[1 2 1]]
Board after 8
move [[2 0 2]
[1 1 2]
[1 2 1]]
Board after 9
move [[2 1 2]
[1 1 2]
[1 2 1]]
Winner is: -1

Artificial Intelligence Manual

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

# Recursive function which prints the # intermediate steps to reach

the final # solution and return boolean value
# (True if solution is possible, otherwise False).
# amt1 and amt2 are the amount of water
present # in both jugs at a certain point of
time. def waterJugSolver(amt1, amt2):

# Checks for our goal

and # returns true if
achieved.
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)

# Changes the boolean value of # the combination as it is visited.

visited[(amt1, amt2)] = True

# Check for all the 6 possibilities and

# see if a solution is found in any one of them.
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))))

# Return False if the combination is

# already visited to avoid repetition otherwise
# recursion will enter an infinite loop.
else:
return False

print("Steps: ")

Artificial Intelligence Manual

 # Call the function and pass the
# initial amount of water present in both jugs.
waterJugSolver(0, 0)

Output:

Steps:

0 0
4 0
4 3
0 3
3 0
3 3
4 2
0 2

True

Artificial Intelligence Manual