Scribd
Upload
2K views6 pages

DAA Lab: Algorithm Complexity Analysis

This document contains a lab session on algorithms and asymptotic notations. It includes pre-lab, in-lab, and post-lab tasks focused on analyzing time complexity of algorithms and sorting arrays. The pre-lab tasks involve calculating time complexity for two algorithms. The in-lab tasks involve sorting arrays of strings by frequency and alphabetical order. The post-lab tasks involve sorting strings by number of uppercase letters and analyzing the time complexity of a binary search algorithm.

Uploaded by

Dheeraj Chalasani
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
2K views6 pages

DAA Lab: Algorithm Complexity Analysis

This document contains a lab session on algorithms and asymptotic notations. It includes pre-lab, in-lab, and post-lab tasks focused on analyzing time complexity of algorithms and sorting arrays. The pre-lab tasks involve calculating time complexity for two algorithms. The in-lab tasks involve sorting arrays of strings by frequency and alphabetical order. The post-lab tasks involve sorting strings by number of uppercase letters and analyzing the time complexity of a binary search algorithm.

Uploaded by

Dheeraj Chalasani
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd

20CS2220RA DESIGN & ANALYSIS OF ALGORITHMS

LAB SESSION 01:


INTRODUCTION TO ALGORITHMS & ASYMPTOTIC NOTATIONS

Date of the Session: / / Time of the Session: to

Pre-Lab:

1) Calculate the time complexity of the following:

Algoritm KLU(int n)
{
int count=0;
for(int i=0;i<n;i=i*2)
{
for(int j=n;j>0;j=j/3)
{
for(int k=0;k<n;k++)
{
Count++;
}
}
}
}

Solution:

8
20CS2220RA DESIGN & ANALYSIS OF ALGORITHMS

2) Calculate the time Complexity of the following:

int recursive(int n)
{
if(n==1)
return (1);
else
return(recursive (n-1) + recursive (n-1));}

Solution:

9
20CS2220RA DESIGN & ANALYSIS OF ALGORITHMS

In-Lab:

1) Given an array of strings arr[], the task is to sort the array of strings according to frequency of
each string, in ascending order. If two elements have same frequency, then they are to be sorted
in alphabetical order.

Input: arr[] = {“Ramesh”, “Mahesh”, “Mahesh”, “Ramesh”}

Output: (“Mahesh”,”Ramesh”}

Explanation:
As both the strings have same frequency, the array is sorted in the alphabetical order.

Solution:

10
20CS2220RA DESIGN & ANALYSIS OF ALGORITHMS

2) Given an array of strings words[] and the sequential order of alphabets, our task is to sort the
array according to the order given. Assume that the dictionary and the words only contain
lowercase alphabets.

Input: words = {“word”, “world”, “row”}, order = “worldabcefghijkmnpqstuvxyz”

Output: “world”,“word”,“row”

Explanation:
According to the given order ‘l’ occurs before ‘d’ hence the words “world” will be kept first.

Solution:

11
20CS2220RA DESIGN & ANALYSIS OF ALGORITHMS

Post-Lab Task:

1) Given an array arr[] of N strings, the task is to sort these strings according to the number of upper-case
letters in them try to use zip function to get the format.

Input arr[] = {poiNtEr, aRRAy, cOde, foR}


Output: [('cOde', 1), ('foR', 1), ('poiNtEr', 2), ('aRRAy', 3)]

“aRRAy” R, R, A->3 Upper Case Letters


“poiNtEr” N, E->2 Upper Case Letters
“cOde” O->2 Upper Case Letters
“foR” R->3 Upper Case Letters

Solution:

12
20CS2220RA DESIGN & ANALYSIS OF ALGORITHMS

2) In KLU streets we have lots of electrical poles.


Note: all poles are sorted with respective to their heights.
Professor Hari Vege given the H = height of one pole to Mothi then asked him to print the position of
that pole, here we consider index as a position. Mothi is particularly good at algorithms, so he written
an algorithm to find that position. But he is extremely poor at finding time complexity. Your task is to
help your friend Mothi to analyze the time complexity of the given problem.

Int BinarySearch (int a, int low, int high, int tar)


{
int mid;
if (low > high) return 0;
mid = floor((low + high)/2)
if (a[mid] == tar)
return mid;
else if (tar < a[mid])
return BinarySearch (a, low, mid-1, tar)
else
return BinarySearch (a, mid+1, high, tar)
}

Solution:

13

You might also like