Test: Time Complexity- 1 - Computer Science Engineering (CSE) MCQ

Ans- 5050 ( 100 +99 + 98 + ..... +1 = (100 *101)/2)

It will start comparison from (85, 5), (84, 6), (83, 7) .............. (45, 45), (44, 46)
Hence total number of comparison will be (85-44) + 1 = 41 + 1 = 42

The worst case complexity for merge sort is O(nlogn).

Answer is (d) None of these
We just require n/2 swaps in the worst case. The algorithm is as given below:
Find positive number from left side and negative number from right side and do exchange. Since, at least one of them must be less than or equal to n/2, there cannot be more than n/2 exchanges. An implementation is given below:

One multiplication and recurrence on n/2 . So, we get the recurrence relation for the number of multiplications as

Because array is always sorted just check the 1st two elements. option a.

We can simply do a binary search in the array of natural numbers from 1...n and check if the cube of the number matches n (i.e., check if    This check takes    time and in the worst case we need to do the search  times. So, in this way we can find the cube root in    So, options (A) and (B) are wrong.

Now, a number is represented in binary using logn bit. Since each bit is important in finding the cube root, any cube root finding algorithm must examine each bit at least once. This ensures that complexity of cube root finding algorithm cannot be lower than logn (It must be Ω(logn)). So, (D) is also false and (C) is the correct answer.

This is a trick question. Note that the questions asks about time complexity, not time taken by the program. for time complexity, it doesn’t matter how we store array elements, we always need to access same number of elements of M1 and M2 to multiply the matrices. It is always constant or O(1) time to do element access in arrays, the constants may differ for different schemes, but not the time complexity.

The key part in the code is "counter = 0" in the else part as we can see below.

Lets take the best case. This happens when    for all i,and then the loop executes with time complexity θ(1) for each iteration and hence overall time complexity of θ(n) and we can say time complexity of the code fragment is Ω(n) and hence options a and b are false.

Now, consider the worst case. This happens when a[i] = 0 or when else part is executed. Here, the time complexity of each iteration will be θ(Counter) and after each else, counter is reset to 0. Let k iterations go to the else part during the worst case. Then the worst case time complexity will be 

where X_i is the value of the counter when,    is called. But due to Counter =0after each call to f(), we have, 

Since the time complexity is    we can say it is θ(n) Option (C). (Option D is false because the small o
needs the growth rate to be STRICTLY lower and not equal to or lower as the case for big 0)

IF Counter = 0was not there in else part, then time complexity would be    as in worst case we can have equal number of 0's and 1's in array a giving time complexity 

would give 

number of iteration will be 

this is in GP find sum till