# Time Complexity

Time complexity:  describes how many operations an algorithm has to do relative to its input size.

slow-growing: runtime does not increase with additional input
fast-growing: runtime increases super fast with additional input

O(1):  An algorithm is run in constant time if it requires the same amount of time regardless of the input size.  (e.g. array lookup).

O(logN): runtime decreases at a rate that’s inversely proportional to input size.  (e.g. binary search – narrowing search).

O(n): runtime increases at a rate that’s directly proportional to the input size.  (e.g. a for loop to iterate over every item in an array).

O(n^2): runtime increases at an order of magnitude proportional to the square of its input size.  (e.g. two nested for loops)

O(c^n): With each step the function performs, it’s subsequent step will take longer by an order of magnitude equivalent to a factor of N. (e.g. guessing password combos)

# Big O

Big O notation describes the performance or complexity of an algorithm.

O(1) – Constant time complexity – describes an algorithm (a one-line statement code) that will always execute in the same time (or space) regardless of the size of the input data set. An example is accessing a value of an array.

```var arr = [ 1,2,3,4,5];
arr[2]; // => 3```

O(N) – Linear time complexity – describes an algorithm (usually a loop) whose performance will grow linearly and in direct proportion to the size of the input data set. For example, if the array has 10 items, we have to print 10 times. If it has 1,000 items, we have to print 1,000 times.

`//if we used for loop to print out the values of the arrays`
```for (var i = 0; i < array.length; i++) {
console.log(array[i]);
}
```

O(log N) – Logarithmic time complexity – describes an algorithm where have a large set of data and you halve the dataset at each iteration until you get the result that you’re looking for.  An example of this is finding a word in a dictionary (binary search).   Sorting a deck of cards (merge sort) would be O(N log N).

Other examples:

```Example 1:
for (var i = 1; i < n; i = i * 2)
console.log(i);
}```
```Example 2:
for (i = n; i >= 1; i = i/2)
console.log(i);
}```

O(N2) – Quadratic time complexity – represents an algorithm whose performance is directly proportional to the square of the size of the input data set. This is common with algorithms that involve nested iterations over the data set. Deeper nested iterations will result in O(N3), O(N4) etc.  Examples include checking for duplicates in a deck of cards, bubble sort, selection sort, or insertion sort.

```for(var i = 0; i < length; i++) {     // has O(n) time complexity
for(var j = 0; j < length; j++) { // has O(n^2) time complexity
// More loops?
}
}```

O(2N) – Exponential time complexity – denotes an algorithm whose growth doubles with each addition to the input data set. An example of an O(2N) function is the recursive calculation of Fibonacci numbers.  Another example is trying to break a password by testing every possible combination (assuming numerical password of length N).

Amortized time:

If you do an operation say a million times, you don’t really care about the worst-case or the best-case of that operation – what you care about is how much time is taken in total when you repeat the operation a million times.

So it doesn’t matter if the operation is very slow once in a while, as long as “once in a while” is rare enough for the slowness to be diluted away (that the cost is “amortized”).  Essentially amortised time means “average time taken per operation, if you do many operations“.

Source: stackoverflow

Space complexity:

Sometimes we want to optimize for using less memory instead of (or in addition to) using less time. Talking about memory cost (or “space complexity”) is very similar to talking about time cost and we also use the Big O notation.

# Hackerrank Day 25: Running Time and Complexity

My Solution in Ruby:

To check if n has any divisors, you only need to check up to the square root of n.  For example, if n = 24, then its divisors are:

1,  2,  3,  4

24, 12, 8, 6

This means if  you’re checking 1, 2, 3, 4, you have also already checked their counterparts, which are 24, 12, 8, 6.  Thus, you can set the upper limit of the range to be the square root of 24 (4.899) to shorten the running time.