# Practice Questions on Time Complexity Analysis

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)

My Personal Notes arrow_drop_up If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :

34

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.