O(n)

It is O(n) because of one simple loop over the elements of the input

O(n) - we have to loop through the input which can be of any size or length

man this website sucks for not having ability to close comments. ruined my attempt to solve the exercise

O(n)

We have to run code in each items of an array

He should’ve closed comments because of idiots like you spamming comments with a solution

O(n) * time complexity of anotherFunction

O(n*time complexity of anotherFunction)

O(n) n = length of an array

O(n)

O(n)

O(n)

O(n)

O(n)

one loop: O(n) * Time of anotherFunctions

O(n)

O(n)

O(n * number of operations/runtime in anotherFunction), linear time since function ends only after running through every iteration so runtime depends on size of input and also anotherFunction

O (n * Time-complexity of anotherFunction)

Simply, O(n).

O(n* order of time-complexity of anotherFunction)

O(n) * (runtime of anotherFunction)

O(n)

O(n * order of anotherFunction())

O(n) If anotherFunction runtime is O(1), else it would be O(n * runtime of anotherFunction).

O(n)

O(n) The function is executed for all the input elements till it reaches the last element.

The function is O(n).

O(n) linear time

However, we don't know what the function contains otherfunction ();

O(n)

O(n) Due to N number of times loop is being run.

O(n)

O(n)

O(n)

O(n)

O(n)

O(n)

Since "anotherFunction" function does not accept any input (hence does not depend on "input"), the overall asymptotic complexity is O(n)

O(n)

O(n)

O(n)

O(n) where n is the length of the input

O(n)

O(n) because loop will keep executing based on the length or size of input.

O(N) - the function increase based on the input data

O(n) as for loop depends on the number of inputs.

O(n)

O(N) - Number of operation linearly increases based on input length

O(n) because call to function is linear to the input array size.

O(n) because it goes through the loop

O(n)

O(n) assuming that anotherFunction() has a linear time complexity.

O(n)

O(n) imo

O(nxm) --> where m is time complexity of anotherfunctions().

o(n)

O(n^n) bcoz another function is called for every iteration.

O(n * x) since we don't know the operation that is performed under anotherFunction()

The big O of the function is O(n)

O(n)

O(n)

O(n)

O(n)

0(n)

o(n)

o(n)

unkown since we don't know the otherFunction big o, but we do know that O would be at least O(n) since there is a loop with N iterations.

O(n)

Okay, so when I run the code it shows that anotherFunction is not declared:(. So, the function performs O(2) since it performs two operations every time (line 3 and line 4). So, it is considered to be "O(1)" as its a constant. :)

O(n) because as the input increases the addition of a increases

O(n)

O(n)

O(n)

O(n)

o(n)

O(1) because the function is not called so it wont execute

O(n)

Because thats the biggest time complexity there

O(n * k) - k is anotherFunction`s running time

O(n)

O(N)

O(n)

Big O, depends anotherFuntions() also.. Let's say if anotherFunctions takes constant time then: O(n)

Big O of the function is O(n) as it's a linear time complexity. It goes on increasing linearly as the size of input increases.

O(n) is the Big O of the above function

O(n) - Linear time complexity because it depends on the array size of the 'input' parameter.

O(n)

Linear time complexity O(n)

O(n)

O(n)

The number of operations "FunChanllenge()" depends on the parameter 'input' array's size. Because there is loop inside the FunChanllenge() which operates the number of time based on the 'input' array's size. The number of input array's element increase, the number of the operation will increase.

so, the time complexity is O(n).

O(n)

Big O calculates how an algorithm slows down as inputs grow, or the number of operations to be carried out as input of an algorithm grows.

0(n) is linear inputs === operations O(1) is constant inputs === 1 operation

O(n * k) where K is time for running anotherFunction()

O(n)

Lineal 0(n)

O(n)

O(n)

its time complexity is O(n)=O(1)+O(1)+O(n)+n*O(1)+n*O(n)=O(n)

O(n) as the loop increases iterations based on the constant passed in the parameter.

O(n)