# time complexity with an "or" in return statement

• Last Update :
• Techknowledgy :

Short circuiting is the key concept in that case:

`return not solve(n - 1) or not solve(n - 2) or not solve(n - 3)`

In terms of complexity, it's the same as calculating:

`solve(n - 1) + solve(n - 2) + solve(n - 3)`

Suggestion : 2

I just started to learn analysis of algorithms and Big-O notation. I was wondering if the return statement is always time complexity O(1) or it depends on problem size N. For example:,So in python, the return statement in this example is O(1), but in another programming language, it would be consider O(N2)?,I know that the function is placed in the complexity class of O(N^2), but I was wondering about the return statement itself. Thank you in advance!,A "return statement" can do any number of things, so no, we can't just say it is O(1) in all cases.

I just started to learn analysis of algorithms and Big-O notation. I was wondering if the return statement is always time complexity O(1) or it depends on problem size N. For example:

```def double(alist):
new_list = []
for value1 in alist:
for value2 in alist:
new_list.append(value1 * value2)
return new_list```

Suggestion : 3

Last Updated : 29 Jul, 2022

`Hello World`

```Hello World!!!
Hello World!!!
Hello World!!!
Hello World!!!
Hello World!!!
Hello World!!!
Hello World!!!
Hello World!!!```

```Hello World!!!
Hello World!!!
Hello World!!!
Hello World!!!```

```Hello World!!!
Hello World!!!```

Suggestion : 4

How to calculate time complexity of any algorithm or program? The most common metric it’s using Big O notation.,Finding out the time complexity of your code can help you develop better programs that run faster. Some functions are easy to analyze, but when you have loops, and recursion might get a little trickier when you have recursion. After reading this post, you are able to derive the time complexity of any code.,In this chapter, we learned how to calculate the time complexity of our code when we have the following elements:,Very rarely, you have a code without any conditional statement. How do you calculate the time complexity? Remember that we care about the worst-case with Big O so that we will take the maximum possible runtime.

`1234`
```statement1;
statement2;...statementN;```
`1`
`total = time(statement1) + time(statement2) + ...time(statementN)`
`T(n) = t(statement1) + t(statement2) + ...+t(statementN);`
`1234567`

Suggestion : 5

Complexity: how do the resource requirements of a program or algorithm scale, i.e., what happens as the size of the problem being solved gets larger. ,total time = time(statement 1) + time(statement 2) + ... + time(statement k), The time required by a method is proportional to the number of "basic operations" that it performs. Here are some examples of basic operations: ,for loops for (i = 0; i < N; i++) { sequence of statements } The loop executes N times, so the sequence of statements also executes N times. Since we assume the statements are O(1), the total time for the for loop is N * O(1), which is O(N) overall.

```List createList(int N) {
List L = new List();
for (int k = 1; k <= N; k++) L.add(0, new Integer(k));
return L;
}```
```L.add(0, new Integer(1));
...
```statement 1;
statement 2;
...
statement k;```
```if (condition) {
sequence of statements 1
} else {
sequence of statements 2
}```
```for (i = 0; i < N; i++) {
sequence of statements
}```
```for (i = 0; i < N; i++) {
for (j = 0; j < M; j++) {
sequence of statements
}
}```

Suggestion : 6

The table below is to help you understand the growth of several common time complexities, and thus help you judge if your algorithm is fast enough to get an Accepted ( assuming the algorithm is correct ).,Time and space complexity depends on lots of things like hardware, operating system, processors, etc. However, we don't consider any of these factors while analyzing the algorithm. We will only consider the execution time of an algorithm.,Sometimes, there are more than one way to solve a problem. We need to learn how to compare the performance different algorithms and choose the best one to solve a particular problem. While analyzing an algorithm, we mostly consider time complexity and space complexity. Time complexity of an algorithm quantifies the amount of time taken by an algorithm to run as a function of the length of the input. Similarly, Space complexity of an algorithm quantifies the amount of space or memory taken by an algorithm to run as a function of the length of the input.,While analysing an algorithm, we mostly consider \$\$O\$\$-notation because it will give us an upper limit of the execution time i.e. the execution time in the worst case.

Simple solution to this problem is traverse the whole array \$\$A\$\$ and check if the any element is equal to \$\$x\$\$.

```for i: 1 to length of A
if A[i] is equal to x
return TRUE
return FALSE```

1.

```int count = 0;
for (int i = 0; i < N; i++)
for (int j = 0; j < i; j++)
count++;```

```int count = 0;
for (int i = N; i > 0; i /= 2)
for (int j = 0; j < i; j++)
count++;```