The document outlines multiple programs written by Kushagra Chadha that compare various algorithms, including multiplication (LaRussa, normal multiplication, and Karatsuba), sorting (bubble sort, insertion sort, and selection sort), searching (linear and binary), sorting algorithms (merge and quick sort), and solving practical problems like matrix chain multiplication and knapsack. It includes code snippets demonstrating the implementations of these algorithms and methods, as well as examples and output details for each program. Each algorithm is aimed at either improving computational efficiency or solving common algorithmic problems.

1. Kushagra Chadha, 00914807216, C12
Program-1
Aim-To compare various multiplication algorithms
Code:
import date me
def laruss(mul plicand,mul plier):
sum=0;
while(mul plicand>=1):
rim=mul plicand%2
mul plicand=mul plicand/2
if rim==1:
sum=sum+mul plier
mul plier=mul plier*2
return sum
def normalMu plica on(mul plicand,mul plier):
return mul plicand*mul plier
def karatsuba(x, y):
if len(str(x)) == 1 or len(str(y)) == 1:
return x * y
else:
n = max(len(str(x)), len(str(y)))
nby2 = n / 2
a = x / 10 ** (nby2)
b = x % 10 ** (nby2)
c = y / 10 ** (nby2)
d = y % 10 ** (nby2)
ac = karatsuba(a, c)
bd = karatsuba(b, d)
ad_plus_bc = karatsuba(a + b, c + d) - ac - bd
prod = ac * 10 ** (n) + (ad_plus_bc * 10 ** (n/2)) + bd
return prod
print "Mul plica on example by Kushagra"
mul plicand=2345678998765423456789087654321345678986543210987654
3456787654323456789865432345678
mul plier=546789765432456789876543223456789765433456789045567653
476896453576896543757689
print "by La russ method"
print(date me.date me.now())
for i in range(1,100,1):
Kushagra Chadha, 00914807216, C12
1

2. Kushagra Chadha, 00914807216, C12
sum=laruss(mul plicand,mul plier)
print sum
print(date me.date me.now())
print "nn Now by normal mul plica on"
print(date me.date me.now())
for i in range(1,100,1):
product=normalMu plica on(mul plicand,mul plier)
print product
print(date me.date me.now())
print "nn By KaratSubann"
print(date me.date me.now())
for i in range(1,100,1):
karaProduct=karatsuba(mul plicand,mul plier)
print karaProduct
print(date me.date me.now())
OUTPUT
Kushagra Chadha, 00914807216, C12
2

3. Kushagra Chadha, 00914807216, C12
Program-2
Aim-To compare various sorting algorithms
import date me
from random import randint
def bubblesort(arr):
for i in range((len(arr))-1,0,-1):
for j in range(i):
if arr[j]>arr[j+1]:
temp=arr[j]
arr[j]=arr[j+1]
arr[j+1]=temp
return arr
def inser onsort(arr):
for i in range(1, len(arr)):
current = arr[i]
pos = i
while pos > 0 and arr[pos - 1] > current:
arr[pos] = arr[pos - 1]
pos = pos - 1
arr[pos] = current
return arr
def selec onsort(arr):
for i in range(len(arr)-1,0,-1):
index=0
for j in range(1,i+1):
if arr[j]>arr[index]:
index=j
temp=arr[i]
arr[i]=arr[index]
arr[index]=temp
return arr
arr=[]
for i in range(100):
arr.append(randint(0,200))
print "Sor ng program by kushagra chadha"
print "array to be sorted is"
print arr
print "By bubble sort"
print date me.date me.now()
Kushagra Chadha, 00914807216, C12
3

4. Kushagra Chadha, 00914807216, C12
for i in range(100):
sortedarr=bubblesort(arr)
print sortedarr
print date me.date me.now()
print "By selec onsort"
print date me.date me.now()
for i in range(100):
sortedarr=selec onsort(arr)
print sortedarr
print date me.date me.now()
print "By inser onsort"
print date me.date me.now()
for i in range(100):
sortedarr=inser onsort(arr)
print sortedarr
print date me.date me.now()
OUTPUT
Kushagra Chadha, 00914807216, C12
4

5. Kushagra Chadha, 00914807216, C12
Program-3
Aim-To implement linear search and binary search
Code:
import date me
def linearsearch(arr,elem):
for i in arr:
if i==elem:
return True
return False
def binarysearch(arr,elem):
if len(arr)==1:
if elem in arr:
return True
else:
return False
else:
if len(arr)%2==0:
mid=len(arr)/2
else:
mid=(len(arr)/2)+1
if arr[mid]==elem:
return True
elif arr[mid]<elem:
binarysearch(arr[:mid],elem)
elif arr[mid]>elem:
binarysearch(arr[mid:],elem)
arr=[1,10,13,17,18,19,20,21,30,42]
print("Array searching proram -Kushagra Chadha")
elem=int(raw_input("enter Element to search:"))
print "By linear search"
print date me.date me.now()
found=False
for i in range(1,10000):
found=linearsearch(arr,elem)
if found==True:
print "Element found"
print date me.date me.now()
else:
Kushagra Chadha, 00914807216, C12
5

6. Kushagra Chadha, 00914807216, C12
print "Element not found"
print date me.date me.now()
print "By binary search"
print date me.date me.now()
for i in range(1,10000):
found=binarysearch(arr,elem)
if found==True:
print "Element found"
print date me.date me.now()
else:
print "Element not found"
print date me.date me.now()
OUTPUT
Kushagra Chadha, 00914807216, C12
6

7. Kushagra Chadha, 00914807216, C12
Program-4
Aim-To implement merge sort and quicksort algorithm
Code:
import date me
def merge(le , right):
result = []
i, j = 0, 0
while i < len(le ) and j < len(right):
if le [i] <= right[j]:
result.append(le [i])
i += 1
else:
result.append(right[j])
j += 1
result += le [i:]
result += right[j:]
return result
def mergesort(lst):
if len(lst) <= 1:
return lst
middle = int(len(lst) / 2)
le = mergesort(lst[:middle])
right = mergesort(lst[middle:])
return merge(le , right)
def quicksort(arr):
less = []
equal = []
greater = []
if len(arr) > 1:
pivot = arr[0]
for x in arr:
if x < pivot:
less.append(x)
if x == pivot:
equal.append(x)
if x > pivot:
greater.append(x)
Kushagra Chadha, 00914807216, C12
7

8. Kushagra Chadha, 00914807216, C12
return quicksort(less) + equal + quicksort(greater)
else:
return arr
arr=[3, 4, 8, 0, 6, 7, 4, 2, 1, 9, 4, 5]
print "Sor ng Divide and Conquer-Kushagra"
print "By merge sort"
print (date me.date me.now())
for i in range(1,1000):
sort=mergesort(arr)
print sort
print (date me.date me.now())
print "By quick sort"
print date me.date me.now()
for i in range(1,1000):
sort=quicksort(arr)
print sort
print date me.date me.now()
OUTPUT
Kushagra Chadha, 00914807216, C12
8

9. Kushagra Chadha, 00914807216, C12
Program-5
Aim-WAP to analyse random selection algorithm
Code:import random
import date me
def select(data, n):
data = list(data)
if not 0 <= n < len(data):
raise ValueError('not enough elements for the given rank')
while True:
pivot = random.choice(data)
pcount = 0
under, over = [], []
for elem in data:
if elem < pivot:
under.append(elem)
elif elem > pivot:
over.append(elem)
else:
pcount += 1
if n < len(under):
data = under
elif n < len(under) + pcount:
return pivot
else:
data = over
n -= len(under) + pcount
a=input("Input the rank of element: ")
print (date me.date me.now())
for i in range(0,1000,1):
ans=select((10,20,11,3,55,6,8),6)
print ans
print (date me.date me.now())
Kushagra Chadha, 00914807216, C12
9

10. Kushagra Chadha, 00914807216, C12
OUTPUT
Kushagra Chadha, 00914807216, C12
10

11. Kushagra Chadha, 00914807216, C12
Program-6
Aim-WAP to perform Matrix Chain Multiplication
Code:
import sys
def MatrixChainMul plica on(p, n):
m = [[0 for x in range(n)] for x in range(n)]
for i in range(1, n):
m[i][i] = 0
for L in range(2, n):
for i in range(1, n - L + 1):
j = i + L - 1
m[i][j] = sys.maxint
for k in range(i, j):
q = m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j]
if q < m[i][j]:
m[i][j] = q
return m[1][n - 1]
arr = [5, 4, 3, 2, 1]
size = len(arr)
print("Minimum number of mul plica ons is " +
str(MatrixChainMul plica on(arr, size)))
OUTPUT
Kushagra Chadha, 00914807216, C12
11

12. Kushagra Chadha, 00914807216, C12
Program-&
Aim-WAP to find Longest Common Subsequence
Code:
def lcs(X, Y, m, n):
L = [[0 for x in xrange(n + 1)] for x in xrange(m + 1)]
for i in xrange(m + 1):
for j in xrange(n + 1):
if i == 0 or j == 0:
L[i][j] = 0
elif X[i - 1] == Y[j - 1]:
L[i][j] = L[i - 1][j - 1] + 1
else:
L[i][j] = max(L[i - 1][j], L[i][j - 1])
print "array is-"
for i in L:
print i
index = L[m][n]
lcs = [""] * (index + 1)
lcs[index] = "0"
i = m
j = n
while i > 0 and j > 0:
if X[i - 1] == Y[j - 1]:
lcs[index - 1] = X[i - 1]
i=i- 1
j=j- 1
index =index- 1
elif L[i - 1][j] > L[i][j - 1]:
i =i-1
else:
j =j- 1
print "LCS of " + X + " and " + Y + " is " + "".join(lcs)
print "length of lcs is "+str(L[m][n])
a = "ushar"
b = "kushagra"
x = len(a)
y = len(b)
lcs(a, b, x, y)
Kushagra Chadha, 00914807216, C12
12

13. Kushagra Chadha, 00914807216, C12
OUTPUT
Kushagra Chadha, 00914807216, C12
13

14. Kushagra Chadha, 00914807216, C12
Program-7
Aim-WAP to solution to Knapsack problem
Code:
def knapSack(W, wt, val, n):
K = [[0 for x in range(W+1)] for x in range(n+1)]
for i in range(n+1):
for w in range(W+1):
if i==0 or w==0:
K[i][w] = 0
elif wt[i-1] <= w:
K[i][w] = max(val[i-1] + K[i-1][w-wt[i-1]], K[i-1][w])
else:
K[i][w] = K[i-1][w]
return K
val = [5, 10, 15]
wt = [1, 4, 20]
for i in range(len(val)):
print("value is-"+str(val[i])+" weight is"+str(wt[i]))
W = int(raw_input("Enter weight wanted"))
n = len(val)
a=knapSack(W, wt, val, n)
for i in a:
print i
print ("Total value is:"+str(a[-1][-1]))
OUTPUT
Kushagra Chadha, 00914807216, C12
14

15. Kushagra Chadha, 00914807216, C12
Kushagra Chadha, 00914807216, C12
15

16. Kushagra Chadha, 00914807216, C12
Program-9
Aim-WAP to solution to activity selection problem
Code:
def bubblesort(start,end):
for i in range((len(end))-1,0,-1):
for j in range(i):
if end[j]>end[j+1]:
temp=end[j]
end[j]=end[j+1]
end[j+1]=temp
temp=start[j]
start[j]=start[j+1]
start[j]=temp
return start,end
def printMaxAc vi es(s, f):
n = len(f)
print "The following ac vi es are selected"
i = 0
print i,
for j in xrange(n):
if s[j] >= f[i]:
print j,
i = j
s=[]
f=[]
count=int(raw_input("Enter the number of ac vi es"))
for i in range(count):
s.append(int(raw_input("Enter start me")))
f.append(int(raw_input("Enter End me")))
s,f=bubblesort(s,f)
printMaxAc vi es(s, f)
Kushagra Chadha, 00914807216, C12
16

17. Kushagra Chadha, 00914807216, C12
OUTPUT
Kushagra Chadha, 00914807216, C12
17

18. Kushagra Chadha, 00914807216, C12
Program-10
Aim-WAP to implement Dijkstra’s Algorithm
Code:
def djiktra(nodes,distances,start):
unvisited = {node: None for node in nodes} #using None as +inf
visited = {}
current = start
currentDistance = 0
unvisited[current] = currentDistance
while True:
for neighbour, distance in distances[current].items():
if neighbour not in unvisited: con nue
newDistance = currentDistance + distance
if unvisited[neighbour] is None or unvisited[neighbour] > newDistance:
unvisited[neighbour] = newDistance
visited[current] = currentDistance
del unvisited[current]
if not unvisited: break
candidates = [node for node in unvisited.items() if node[1]]
current, currentDistance = sorted(candidates, key = lambda x: x[1])[0]
return visited
nodes = ('A', 'B', 'C', 'D', 'E', 'F', 'G')
distances = {
'B': {'A': 5, 'D': 1, 'G': 2},
'A': {'B': 5, 'D': 3, 'E': 12, 'F' :5},
'D': {'B': 1, 'G': 1, 'E': 1, 'A': 3},
'G': {'B': 2, 'D': 1, 'C': 2},
'C': {'G': 2, 'E': 1, 'F': 16},
'E': {'A': 12, 'D': 1, 'C': 1, 'F': 2},
'F': {'A': 5, 'E': 2, 'C': 16}}
print "Nodes are:"
print distances
start=raw_input("Enter start node").upper()
print(djiktra(nodes,distances,start))
Kushagra Chadha, 00914807216, C12
18

19. Kushagra Chadha, 00914807216, C12
OUTPUT
Kushagra Chadha, 00914807216, C12
19

20. Kushagra Chadha, 00914807216, C12
Program-11
Aim-WAP to implement floyd-warshall Algorithm
Code:
V = 4
def floydWarshall(graph):
dist = map(lambda i: map(lambda j: j, i), graph)
for k in range(V):
for i in range(V):
for j in range(V):
dist[i][j] = min(dist[i][j],dist[i][k] + dist[k][j])
printSolu on(dist)
def printSolu on(dist):
print "Shortest pair matrix"
for i in range(V):
for j in range(V):
if (dist[i][j] == 99999):
print "%7s" % (99999),
else:
print "%7dt" % (dist[i][j]),
if j == V - 1:
print ""
graph = [[0, 5, 99999, 10],
[99999, 0, 3, 99999],
[99999, 99999, 0, 1],
[99999, 99999, 99999, 0]
]
ver ces=int(raw_input("Enter the number of ver ces: "))
a = [[None for _ in range(ver ces)] for _ in range(ver ces)]
for i in range(ver ces):
for j in range(ver ces):
if i==j:
a[i][j]=0
con nue
a[i][j]=int(raw_input("Enter distance between node "+str(i)+" and
node"+str(j)+"(enter 99999 for no connecc on)"))
floydWarshall(graph);
Kushagra Chadha, 00914807216, C12
20

21. Kushagra Chadha, 00914807216, C12
OUTPUT
Kushagra Chadha, 00914807216, C12
21