DAA Record - Print
DAA Record - Print
1
EXP NO: 1 RECURSIVE ALGORITHM
Date:
EX-1.1 FIBONACCI SERIES
AIM:
ALGORITHM:
2
CODING:
def recursive_fibonacci(n):
if n <= 1:
return n
else:
return(recursive_fibonacci(n-1) + recursive_fibonacci(n-2))
n_terms = 10
if n_terms <= 0:
else:
print("Fibonacci series:")
for i in range(n_terms):
print(recursive_fibonacci(i))
def recursive_algorithm(n):
if n <= 1:
return 1
return recursive_algorithm(n-1) * n
def non_recursive_algorithm(n):
result = 1
for i in range(1, n+1):
result *= i
return result
3
Output
Fibonacci series:
0
1
1
2
3
5
8
13
21
34
RESULT:
4
EX-1.2 BINARY SEARCH USING RECURSION
Date:
AIM:
ALGORITHM:
5
CODING:
if r >= l:
mid = l + (r - l) // 2
if arr[mid] == x:
return mid
elif arr[mid] > x:
return binarySearch(arr, l, mid-1, x)
else:
return binarySearch(arr, mid + 1, r, x)
else:
return -1
arr = [2, 3, 4, 10, 40]
x = 10
result = binarySearch(arr, 0, len(arr)-1, x)
if result != -1:
print("Element is present at index % d" % result)
else:
print("Element is not present in array")
OUTPUT:
Element is present at index 3
RESULT:
6
EX-1.3 BINARY SEARCH USING ITERATION METHOD
Date:
AIM:
ALGORITHM:
7
CODING:
if v[lo] == To_Find:
print("Found At Index", lo)
elif v[hi] == To_Find:
print("Found At Index", hi)
else:
print("Not Found")
OUTPUT:
Found At Index 4
Not Found
RESULT:
8
EXP NO: 2 FINDING MINIMUM AND MAXIMUM ELEMENT IN ARRAY USING DIVIDE
AND CONQUER
Date:
AIM:
ALGORITHM:
9
CODING:
if __name == '__main__':
# array initialization
arr = [6, 4, 8, 90, 12, 56, 7, 1, 63];
10
OUTPUT
RESULT:
11
EXP NO: 2-2 STRASSEN’S MULTIPLICATION
Date:
AIM:
ALGORITHM:
12
CODING:
import numpy as np
def strassen(A, B):
if A.shape == (1, 1): # base case
return A * B
else: # divide matrices into quadrants
n = A.shape[0]
m = n // 2
a = A[:m, :m]
b = A[:m, m:]
c = A[m:, :m]
d = A[m:, m:]
e = B[:m, :m]
f = B[:m, m:]
g = B[m:, :m]
h = B[m:, m:]
OUTPUT:
[[19 22]
[43 50]]
RESULT:
13
EXP NO: 3 DECREASE AND CONQUER - TOPOLOGICAL SORTING
Date:
AIM:
ALGORITHM:
14
CODING:
class Graph:
def __init__(self,vertices):
def addEdge(self,u,v):
self.graph[u].append(v)
def topologicalSortUtil(self,v,visited,stack):
visited[v] = True
for i in self.graph[v]:
if visited[i] == False:
self.topologicalSortUtil(i,visited,stack)
stack.insert(0,v)
def topologicalSort(self):
visited = [False]*self.V
stack =[]
for i in range(self.V):
if visited[i] == False:
self.topologicalSortUtil(i,visited,stack)
print (stack)
g= Graph(6)
g.addEdge(5, 2);
g.addEdge(5, 0);
g.addEdge(4, 0);
g.addEdge(4, 1);
g.addEdge(2, 3);
g.addEdge(3, 1);
OUTPUT
[5, 4, 2, 3, 1, 0]
RESULT:
16
EXP NO:4 TRANSFORM AND CONQUER - HEAP SORT
Date:
AIM:
ALGORITHM:
17
CODING
largest = il
= 2 * i + 1r
=2*i+2
largest = l
largest = r
if largest != i:
heapify(arr, n, largest)
def heapSort(arr):
n = len(arr)
heapify(arr, n, i)
heapify(arr, i, 0)
heapSort(arr)
n = len(arr)
for i in range(n):
print(arr[i])
18
OUTPUT
Sorted array is
11
12
13
RESULT:
19
Exp No: 5 DYNAMIC CODINGMING
Date:
EX-5.1 COIN CHANGE PROBLEM
AIM:
ALGORITHM
20
CODING
INF = 100000
if x < y:
return x
return y
minimum = INF
M[j] = minimum
return M[n]
d = [0, 1, 2, 3]
print(coin_change(d, 5, 3))
OUTPUT
RESULT:
21
EX-5.2 WARSHALL’S AND FLOYD’S ALGORITHM
Date:
AIM:
ALGORITHM:
22
CODING:
nV = 4
INF = 999
def floyd_warshall(G):
for k in range(nV):
for i in range(nV):
for j in range(nV):
print_solution(distance)
def print_solution(distance):
for i in range(nV):
for j in range(nV):
if(distance[i][j] == INF):
print(" ")
[INF, 1, 0, INF],
floyd_warshall(G)
23
OUTPUT
0 3 7 5
2 0 6 4
3 1 0 5
5 3 2 0
RESULT:
24
EX-5.3 KNAPSACK PROBLEM
Date:
AIM:
ALGORITHM
25
CODING:
if i == 0 or w == 0:
K[i][w] = 0
else:
K[i][w] = K[i-1][w]
return K[n][W]
W = 50
n = len(val)
OUTPUT
220
RESULT
26
EXP NO: 6 GREEDY TECHNIQUES
Date:
EX-6.1 DIJIKSTRA’S ALGORITHM
AIM
ALGORITHM
27
CODING:
class Graph():
self.V = vertices
min = 1e7
for v in range(self.V):
min = dist[v]
min_index = v
return min_index
dist[src] = 0
u = self.minDistance(dist, sptSet)
sptSet[u] = True
for v in range(self.V):
g = Graph(9)
[0, 8, 0, 7, 0, 4, 0, 0, 2],
[0, 0, 0, 0, 0, 2, 0, 1, 6],
[0, 0, 2, 0, 0, 0, 6, 7, 0]
]
g.dijkstra(0)
OUTPUT
RESULT
29
EX-6.2 HUFFMAN TREES AND CODES
Date:
AIM
ALGORITHM
30
CODING:
string = 'BCAADDDCCACACAC'
class NodeTree(object):
self.left = left
self.right = right
def children(self):
if type(node) is str:
(l, r) = node.children()
d = dict()
return d
freq = {}
for c in string:
if c in freq:
freq[c] += 1
else:
freq[c] = 1
nodes = freq
31
while len(nodes) > 1:
nodes = nodes[:-2]
nodes.append((node, c1 + c2))
huffmanCode = huffman_code_tree(nodes[0][0])
OUTPUT
----------------------
'C' | 0
'A' | 11
'D' | 101
'B' | 100
RESULT:
32
EXP NO: 7 ITERATIVE IMPROVEMENT - SIMPLEX ALGORITHM
Date:
AIM:
ALGORITHM :
33
Coding :
34
OUTPUT:
Iterations: 3
fun: -59400.0
nit: 3
status: 0
success: True
RESULT:
35
EXP NO: 8 BACKTRACKING
Date:
EX-8.1 N-QUEEN PROBLEM
AIM:
ALGORITHM:
36
CODING:
N = int(input("Enter the number of queens : "))
for k in range(0,N):
if board[i][k]==1 or board[k][j]==1:
return True
for k in range(0,N):
for l in range(0,N):
if (k+l==i+j) or (k-l==i-j):
if board[k][l]==1:
return True
return True
for i in range(0,N):
for j in range(0,N):
board[i][j] = 1
if N_queens(n-1)==True:
return True
board[i][j] = 0
return False
N_queens(N)
for i in board:
print (i)
37
OUTPUT:
[0, 0, 0, 1]
[1, 0, 0, 0]
[0, 0, 1, 0]
RESULT:
38
EX-8.2 SUBSET SUM PROBLEM
Date:
AIM:
ALGORITHM:
39
CODING:
if (sum == 0) :
return True
if (n == 0 and sum != 0) :
return False
if (set[n - 1] > sum) :
n = len(set)
if (isSubsetSum(set, n, sum) == True) :
else :
print("No subset with given sum")
OUTPUT:
40
# A RECURSIVE SOLUTION FOR SUBSET SUM PROBLEM
# Returns true if there is a subset of set[ ] with sun equal to given sum
def sum_of_subset(s,k,rem):
x[k]=1
if s+my_list[k]==target_sum:
list1=[]
for i in range (0,k+1):
if x[i]==1:
list1.append(my_list[i])
print( list1 )
elif s+my_list[k]+my_list[k+1]<=target_sum :
sum_of_subset(s+my_list[k],k+1,rem-my_list[k])
if s+rem-my_list[k]>=target_sum and s+my_list[k+1]<=target_sum :
x[k]=0
sum_of_subset(s,k+1,rem-my_list[k])
my_list=[]
n=int(input("Enter number of elements"))
total=0
for i in range (0,n):
ele=int(input())
my_list.append(ele)
total=total+ele
my_list.sort()
target_sum=int(input("Enter required Sum"))
x=[0]*(n+1)
sum_of_subset(0,0,total)
OUTPUT:
41
EXP NO: 9 BRANCH AND BOUND -- TRAVELLING SALESMAN PROBLEM
Date:
AIM:
ALGORITHM
42
CODING:
from sys import maxsize
V=4
vertex = []
for i in range(V):
if i != s:
vertex.append(i)
min_path = maxsize
next_permutation=permutations(vertex)
for i in next_permutation:
current_pathweight = 0
k=s
for j in i:
current_pathweight += graph[k][j]
k=j
current_pathweight += graph[k][s]
return min_path
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
RESULT:
43