MATU RAM INSTITUTE OF ENGINEERING

AND MANAGEMENT

Practical File of
Artificial Intelligence

Submitted to: Submitted by:

Mrs. Jyoti Ahlawat Saloni Khatri
Assistant Professor 5627 (B.Tech CSE)
CSE Department 6th Semester
 Index
1 Write a program to print ‘HELLO WORLD’ in python
2 Write a program to add two numbers with user input
3 Write a program to swap two variables
4 Write a program to check if a number is positive, negative or 0
5 Write a program to check if a number is even or odd
6 Write a program to check leap year
7 Write a program to check prime number
8 Write a program to find factorial of number using recursion
9 Write a program to create Pyramid Patterns
10 Write a program to implement Inheritance
11 Write a program to implement python List operation
12 Write a program in python to create class and object
13 Write a program in python to implement polymorphism
14 Write a program to implement breadth first search using python
15 Write a program to implement depth first search using python
16 Write a program to implement water jug problem using python
17 Write a program to implement travelling salesman problem in python
18 Write a program to implement Tower of Hanoi using python
19 Write a program to implement 8 Queen Problem using python
20 Write a python program to implement MATPLOT Library
21 Write a python program to implement MATPLOT LABEL
22 Write a python program to implement MATPLOT BAR GRAPH
1. Write a program to print ‘HELLO WORLD’ in python.

# This program prints 'HELLO WORLD'

print("Hello, World!")

Output:

Hello, World!
2. Write a program to add two numbers with user input.
# Python program to add two numbers
num1 = 15
num2 = 12

# Adding two nos

sum = num1 + num2

# printing values
print("Sum of", num1, "and", num2 , "is", sum)

Output:

Sum of 15 and 12 is 27
3. Write a program to swap two variables.

# Python program to demonstrate

# swapping of two variables

x = 10
y = 50

# Swapping of two variables

# Using third variable
temp = x
x = y
y = temp

print("Value of x:", x)
print("Value of y:", y)

Output:

Value of x: 50
Value of y: 10
4. Write a program to check if a number is positive,
negative or 0.

# Python program to check whether the number is positive,

negative or #equal to zero

def check(n):

# if the number is positive

if n > 0:
print("Positive")

# if the number is negative

elif n < 0:
print("Negative")

# if the number is equal to

# zero
else:
print("Equal to zero")

# Driver Code
check(5)
check(0)
check(-5)

Output:

Positive
Equal to zero
Negative
5. Write a program to check if a number is even or odd.

x = 24

if x % 24 == 0:
print(x,"Is Even Number")
else:
print(x, "Is Odd Number")

y = 19

if y % 19 == 0:
print(y,"Is Even Number")
else:
print(y, "Is Odd Number")

Output:

24 Is Even Number
19 Is Even Number
 6. Write a program to check leap year.

def is_leap_year_modulo(year):
return (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0)

# Example
year_to_check = 2024
result_modulo = is_leap_year_modulo(year_to_check)
print(f"{year_to_check} is a leap year: {result_modulo}")

Output:

2024 is a leap year: True

 7. Write a program to check prime number.

num = 11
# If given number is greater than 1
if num > 1:
# Iterate from 2 to n // 2
for i in range(2, (num//2)+1):
# If num is divisible by any number between
# 2 and n / 2, it is not prime
if (num % i) == 0:
print(num, "is not a prime number")
break
else:
print(num, "is a prime number")
else:
print(num, "is not a prime number")

Output:

11 is a prime number
8. Write a program to find factorial of number using
recursion.

# Python 3 program to find factorial of given number

def factorial(n):

# Checking the number

# is 1 or 0 then
# return 1
# other wise return
# factorial
if (n==1 or n==0):

return 1

else:

return (n * factorial(n - 1))

# Driver Code
num = 5;
print("number : ",num)
print("Factorial : ",factorial(num))

Output:

number : 5
Factorial : 120
 9. Write a program to create Pyramid Patterns.

# Function to print full pyramid pattern

def full_pyramid(n):
for i in range(1, n + 1):
# Print leading spaces
for j in range(n - i):
print(" ", end="")

# Print asterisks for the current row

for k in range(1, 2*i):
print("*", end="")

Output:

*
***
*****
*******
*********
10.Write a program to implement Inheritance.

class Animal:
# attribute and method of the parent class
name = ""

def eat(self):
print("I can eat")

# inherit from Animal

class Dog(Animal):
# new method in subclass
def display(self):
# access name attribute of superclass using self
print("My name is ", self.name)
# create an object of the subclass
labrador = Dog()

# access superclass attribute and method

labrador.name = " Dollar "
labrador.eat()

# call subclass method

labrador.display()

Output:
I can eat
My name is Dollar
11.Write a program to implement python List operation.

thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]

print(thislist[2:5])

thislist = ["apple", "banana", "cherry", "orange", "kiwi", "melon", "mango"]

print(thislist[2:])

Output:

['cherry', 'orange', 'kiwi']

['cherry', 'orange', 'kiwi', 'melon', 'mango']
12.Write a program in python to create class and object.

class Person:
def init (self, name, age):
self.name = name
self.age = age

p1 = Person("Saloni", 20)

print(p1.name)
print(p1.age

Output:
Saloni
20
13.Write a program in python to implement polymorphism.
class Car:
def init (self, brand, model):
self.brand = brand
self.model = model

def move(self):
print(" C R E T A ")

class Boat:
def init (self, brand, model):
self.brand = brand
self.model = model

def move(self):
print(" H Y U N D A I ")

class Plane:
def init (self, brand, model):
self.brand = brand
self.model = model
def move(self):
print(2022)
car1 = Car("Ford", "Mustang") #Create a Car class
boat1 = Boat("Ibiza", "Touring 20") #Create a Boat class
plane1 = Plane("Boeing", "747") #Create a Plane class

for x in (car1, boat1, plane1):

x.move()

Output:
C R E T A
H Y U N D A I
2022
14.Write a program to implement breadth first search using
python.

# Python Program to print BFS traversal from a given source vertex.

BFS(int s) traverses vertices reachable from s.

from collections import defaultdict

# This class represents a directed graph using adjacency list

representation
class Graph:

# Constructor
def __init__(self):

# Default dictionary to store graph

self.graph = defaultdict(list)

# Function to add an edge to graph

def addEdge(self, u, v):
self.graph[u].append(v)

# Function to print a BFS of graph

def BFS(self, s):

# Mark all the vertices as not visited

visited = [False] * (max(self.graph) + 1)

# Create a queue for BFS

queue = []

# Mark the source node as visited and enqueue it

queue.append(s)
visited[s] = True

while queue:

# Dequeue a vertex from queue and print it

 s = queue.pop(0)
print(s, end=" ")

# Get all adjacent vertices of the dequeued vertex s.

# If an adjacent has not been visited, then mark it
visited and enqueue it
for i in self.graph[s]:
if visited[i] == False:
queue.append(i)
visited[i] = True

# Driver code
if __name__ == '__main__':

# Create a graph given in the above diagram

g = Graph()
g.addEdge(0, 1)
g.addEdge(0, 2)
g.addEdge(1, 2)
g.addEdge(2, 0)
g.addEdge(2, 3)
g.addEdge(3, 3)

print("Following is Breadth First Traversal"

" (starting from vertex 2)")
g.BFS(2)

Output:
Following is Breadth First Traversal (starting from vertex 2)
2 0 3 1
15.Write a program to implement depth first search using
python.

# Python program to print DFS traversal from a given graph

from collections import defaultdict

# This class represents a directed graph using adjacency list

representation
class Graph:

# Constructor
def __init__(self):

# Default dictionary to store graph

self.graph = defaultdict(list)

# Function to add an edge to graph

def addEdge(self, u, v):
self.graph[u].append(v)

# A function used by DFS

def DFSUtil(self, v, visited):

# Mark the current node as visited and print it

visited.add(v)
print(v, end=' ')

# Recur for all the vertices adjacent to this vertex

for neighbour in self.graph[v]:
if neighbour not in visited:
self.DFSUtil(neighbour, visited)

# The function to do DFS traversal. It uses recursive DFSUtil()

def DFS(self, v):
 # Create a set to store visited vertices
visited = set()

# Call the recursive helper function to print DFS traversal

self.DFSUtil(v, visited)

# Driver's code
if __name__ == "__main__":
g = Graph()
g.addEdge(4, 5)
g.addEdge(4, 6)
g.addEdge(5, 6)
g.addEdge(6, 4)
g.addEdge(6, 7)
g.addEdge(7, 7)

print("Following is Depth First Traversal (starting from vertex

6)")

# Function call
g.DFS(6)

Output:
Following is Depth First Traversal (starting from vertex 6)
6 4 5 7
16.Write a program to implement water jug problem using
python.

#Python program to solve water jug problem

from collections import deque

def BFS(a, b, target):

m = {}
isSolvable = False
path = []

q = deque()

q.append((0, 0))

while (len(q) > 0):

u = q.popleft() # If this state is already visited
if ((u[0], u[1]) in m):
continue
if ((u[0] > a or u[1] > b or
u[0] < 0 or u[1] < 0)):
continue

# Filling the vector for constructing the solution path

path.append([u[0], u[1]])

# Marking current state as visited

m[(u[0], u[1])] = 1

# If we reach solution state, put ans=1

if (u[0] == target or u[1] == target):
isSolvable = True

if (u[0] == target):
if (u[1] != 0):
 # Fill final state
path.append([u[0], 0])
else:
if (u[0] != 0):

# Fill final state

path.append([0, u[1]])

# Print the solution path

sz = len(path)
for i in range(sz):
print("(", path[i][0], ",",
path[i][1], ")")
break

# If we have not reached final state then, start developing

intermediate states to reach solution state
q.append([u[0], b]) # Fill Jug2
q.append([a, u[1]]) # Fill Jug1

for ap in range(max(a, b) + 1):

# Pour amount ap from Jug2 to Jug1

c = u[0] + ap
d = u[1] - ap

# Check if this state is possible or not

if (c == a or (d == 0 and d >= 0)):
q.append([c, d])

# Pour amount ap from Jug 1 to Jug2

c = u[0] - ap
d = u[1] + ap

# Check if this state is possible or not

if ((c == 0 and c >= 0) or d == b):
q.append([c, d])

# Empty Jug2
q.append([a, 0])

# Empty Jug1
q.append([0, b])

# No, solution exists if ans=0

 if (not isSolvable):
print("No solution")

# Driver code
if __name__ == '__main__':

Jug1, Jug2, target = 4, 3, 2

print("Path from initial state "
"to solution state ::")

BFS(Jug1, Jug2, target)

Output:

( 0 , 0 )
( 0 , 3 )
( 4 , 0 )
( 4 , 3 )
( 3 , 0 )
( 1 , 3 )
( 3 , 3 )
( 4 , 2 )
( 0 , 2 )
17.Write a program to implement travelling salesman problem
in python.

# Python3 program to implement traveling salesman

# problem using naive approach.
from sys import maxsize
from itertools import permutations
V = 4

# implementation of traveling Salesman Problem

def travellingSalesmanProblem(graph, s):

# store all vertex apart from source vertex

vertex = []
for i in range(V):
if i != s:
vertex.append(i)

# store minimum weight Hamiltonian Cycle

min_path = maxsize
next_permutation=permutations(vertex)
for i in next_permutation:

# store current Path weight(cost)

current_pathweight = 0

# compute current path weight

k = s
for j in i:
current_pathweight += graph[k][j]
k = j
current_pathweight += graph[k][s]

# update minimum
min_path = min(min_path, current_pathweight)

return min_path
# Driver Code
if __name__ == "__main__":

# matrix representation of graph

graph = [[0, 10, 15, 20], [10, 0, 35, 25],
[15, 35, 0, 30], [20, 25, 30, 0]]
s = 0
print(travellingSalesmanProblem(graph, s))

Output:

80
18.Write a program to implement Tower of Hanoi using python.

# Recursive Python function to solve the tower of hanoi

def TowerOfHanoi(n , source, destination, auxiliary):

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

# Driver code
n = 4
TowerOfHanoi(n,'A','B','C')
# A, C, B are the name of rods

Output:

Move disk 1 from source A to destination C

Move disk 2 from source A to destination B
Move disk 1 from source C to destination B
Move disk 3 from source A to destination C
Move disk 1 from source B to destination A
Move disk 2 from source B to destination C
Move disk 1 from source A to destination C
Move disk 4 from source A to destination B
Move disk 1 from source C to destination B
Move disk 2 from source C to destination A
Move disk 1 from source B to destination A
Move disk 3 from source C to destination B
Move disk 1 from source A to destination C
Move disk 2 from source A to destination B
Move disk 1 from source C to destination B

19.Write a program to implement 8 Queen Problem using

python.

# Python program to print the path from root node to destination node
for N*N-1 puzzle algorithm using Branch and Bound
#The solution assumes that instance of puzzle is solvable

# Importing copy for deepcopy function

import copy

# Importing the heap functions from python library for Priority Queue
from heapq import heappush, heappop

# This variable can be changed to change the program from 8

puzzle(n=3) to 15 puzzle(n=4) to 24 puzzle(n=5)...
n = 3

# bottom, left, top, right

row = [ 1, 0, -1, 0 ]
col = [ 0, -1, 0, 1 ]

# A class for Priority Queue

class priorityQueue:

# Constructor to initialize a Priority Queue

def __init__(self):
self.heap = []

# Inserts a new key 'k'

def push(self, k):
heappush(self.heap, k)

# Method to remove minimum element from Priority Queue

 def pop(self):
return heappop(self.heap)

# Method to know if the Queue is empty

def empty(self):
if not self.heap:
return True
else:
return False

# Node structure
class node:

def __init__(self, parent, mat, empty_tile_pos,

cost, level):

# Stores the parent node of the current node helps in tracing

path when the answer is found
self.parent = parent

# Stores the matrix

self.mat = mat

# Stores the position at which the empty space tile exists in

the matrix
self.empty_tile_pos = empty_tile_pos

# Stores the number of misplaced tiles

self.cost = cost

# Stores the number of moves so far

self.level = level

# This method is defined so that the priority queue is formed

based on the cost variable of the objects
def __lt__(self, nxt):
return self.cost < nxt.cost
# Function to calculate the number of misplaced tiles ie. number of
non-blank tiles not in their goal position
def calculateCost(mat, final) -> int:

count = 0
for i in range(n):
for j in range(n):
if ((mat[i][j]) and
(mat[i][j] != final[i][j])):
count += 1

return count

def newNode(mat, empty_tile_pos, new_empty_tile_pos,

level, parent, final) -> node:

# Copy data from parent matrix to current matrix

new_mat = copy.deepcopy(mat)

# Move tile by 1 position

x1 = empty_tile_pos[0]
y1 = empty_tile_pos[1]
x2 = new_empty_tile_pos[0]
y2 = new_empty_tile_pos[1]
new_mat[x1][y1], new_mat[x2][y2] = new_mat[x2][y2],
new_mat[x1][y1]

# Set number of misplaced tiles

cost = calculateCost(new_mat, final)

new_node = node(parent, new_mat, new_empty_tile_pos,

cost, level)
return new_node

# Function to print the N x N matrix

def printMatrix(mat):

for i in range(n):
for j in range(n):
 print("%d " % (mat[i][j]), end = " ")

print()

# Function to check if (x, y) is a valid matrix coordinate

def isSafe(x, y):

return x >= 0 and x < n and y >= 0 and y < n

# Print path from root node to destination node

def printPath(root):

if root == None:
return

printPath(root.parent)
printMatrix(root.mat)
print()

# Function to solve N*N - 1 puzzle algorithm using Branch and Bound.

empty_tile_pos is the blank tile position in the initial state.
def solve(initial, empty_tile_pos, final):

# Create a priority queue to store live nodes of search tree

pq = priorityQueue()

# Create the root node

cost = calculateCost(initial, final)
root = node(None, initial,
empty_tile_pos, cost, 0)

# Add root to list of live nodes

pq.push(root)

# Finds a live node with least cost, add its children to list of
live nodes and finally deletes it from the list.
while not pq.empty():
 # Find a live node with least estimated cost and delete it
from the list of live nodes
minimum = pq.pop()

# If minimum is the answer node

if minimum.cost == 0:

# Print the path from root to destination;

printPath(minimum)
return

# Generate all possible children

for i in range(4):
new_tile_pos = [
minimum.empty_tile_pos[0] + row[i],
minimum.empty_tile_pos[1] + col[i], ]

if isSafe(new_tile_pos[0], new_tile_pos[1]):

# Create a child node

child = newNode(minimum.mat,
minimum.empty_tile_pos,
new_tile_pos,
minimum.level + 1,
minimum, final,)

# Add child to list of live nodes

pq.push(child)

# Driver Code

# Initial configuration
# Value 0 is used for empty space
initial = [ [ 1, 2, 3 ],
[ 5, 6, 0 ],
[ 7, 8, 4 ] ]

# Solvable Final configuration Value 0 is used for empty space

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

# Blank tile coordinates in initial configuration

empty_tile_pos = [ 1, 2 ]

# Function call to solve the puzzle

solve(initial, empty_tile_pos, final)

Output:

1 2 3
5 0 6
7 8 4

1 2 3
5 8 6
7 0 4

1 2 3
5 8 6
0 7 4
20.Write a python program to implement MATPLOT Library.

# a Python program to implement MATPLOT Library

import matplotlib.pyplot as plt

import numpy as np

ypoints = np.array([3, 8, 1, 10])

plt.plot(ypoints, linestyle = 'dotted')

plt.show()

Output:
21.Write a python program to implement MATPLOT LABEL.

# Python program to implement MATPLOT LABEL

import numpy as np
import matplotlib.pyplot as plt

x = np.array([80, 85, 90, 95, 100, 105, 110, 115, 120, 125])
y = np.array([240, 250, 260, 270, 280, 290, 300, 310, 320, 330])

plt.plot(x, y)

plt.xlabel(" ENGINEERING ")

plt.ylabel(" M.D.U ")

plt.show()

Output:
22.Write a python program to implement MATPLOT BAR GRAPH.

# Python program to implement MATPLOT BAR GRAPH

import matplotlib.pyplot as plt

import numpy as np

x = np.array(["A", "B", "C", "D"])

y = np.array([3, 8, 1, 10])

plt.xlabel(" PATIENT ")

plt.ylabel(" COVID CASES ")

plt.bar(x,y)
plt.show()

Output: