Related Articles
Practice Questions on Time Complexity Analysis
• Difficulty Level : Easy
• Last Updated : 12 Dec, 2017

Prerequiste: Analysis of Algorithms

1. What is the time, space complexity of following code:

 `int` `a = 0, b = 0;``for` `(i = 0; i < N; i++) {``    ``a = a + ``rand``();``}``for` `(j = 0; j < M; j++) {``    ``b = b + ``rand``();``}`

Options:

1. O(N * M) time, O(1) space
2. O(N + M) time, O(N + M) space
3. O(N + M) time, O(1) space
4. O(N * M) time, O(N + M) space

Output:

```3. O(N + M) time, O(1) space
```

Explanation: The first loop is O(N) and the second loop is O(M). Since we don’t know which is bigger, we say this is O(N + M). This can also be written as O(max(N, M)).
Since there is no additional space being utilized, the space complexity is constant / O(1)

2. What is the time complexity of following code:

 `int` `a = 0;``for` `(i = 0; i < N; i++) {``    ``for` `(j = N; j > i; j--) {``        ``a = a + i + j;``    ``}``}`

Options:

1. O(N)
2. O(N*log(N))
3. O(N * Sqrt(N))
4. O(N*N)

Output:

```4. O(N*N)
```

Explanation:
The above code runs total no of times
= N + (N – 1) + (N – 2) + … 1 + 0
= N * (N + 1) / 2
= 1/2 * N^2 + 1/2 * N
O(N^2) times.

3. What is the time complexity of following code:

 `int` `i, j, k = 0;``for` `(i = n / 2; i <= n; i++) {``    ``for` `(j = 2; j <= n; j = j * 2) {``        ``k = k + n / 2;``    ``}``}`

Options:

1. O(n)
2. O(nLogn)
3. O(n^2)
4. O(n^2Logn)

Output:

```2. O(nLogn)
```

Explanation:If you notice, j keeps doubling till it is less than or equal to n. Number of times, we can double a number till it is less than n would be log(n).
Let’s take the examples here.
for n = 16, j = 2, 4, 8, 16
for n = 32, j = 2, 4, 8, 16, 32
So, j would run for O(log n) steps.
i runs for n/2 steps.
So, total steps = O(n/ 2 * log (n)) = O(n*logn)

4. What does it mean when we say that an algorithm X is asymptotically more efficient than Y?
Options:

1. X will always be a better choice for small inputs
2. X will always be a better choice for large inputs
3. Y will always be a better choice for small inputs
4. X will always be a better choice for all inputs
```2. X will always be a better choice for large inputs
```

Explanation: In asymptotic analysis we consider growth of algorithm in terms of input size. An algorithm X is said to be asymptotically better than Y if X takes smaller time than y for all input sizes n larger than a value n0 where n0 > 0.

##### 5. What is the time complexity of following code:
 `int` `a = 0, i = N;``while` `(i > 0) {``    ``a += i;``    ``i /= 2;``}`

Options:

1. O(N)
2. O(Sqrt(N))
3. O(N / 2)
4. O(log N)

Output:

```4. O(log N)
```

Explanation: We have to find the smallest x such that N / 2^x N
x = log(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up