The drawdown of a series is the largest decrease in value between two points. If you were to purchase and sell a stock, the start and end of its drawdown would be the worst time to do so.

Since order matters, calculating drawdown isnâ€™t as simple as finding the maximum and minimum values of the series - if the minimum occurs before the maximum, such an approach will identify a period of appreciation. To avoid this case, we can iterate over each index `i`

of the series, then compare the price at time `i`

to the price at all subsequent indices `j`

. `maxDrawdown`

is equal to the largest difference between prices at `i`

and `j`

:

```
var n = prices.length
for (var i = 0; i < n; i++){
for (var j = i + 1; j < n; j++){
dif = prices[i] - prices[j];
maxDrawdown = maxDrawdown > dif ? maxDrawdown : dif;
}
}
```

While accurate, this algorithm require many value comparisons:

If the series has `n`

prices, `n*(n - 1)/2`

comparisons are needed (the number of comparisons done during the `i`

th pass through the inner loop is `n - i - 1`

; the sum of all those comparisons is `1 + 2 + 3 + ... + n - 1`

). The number of comparisons increases faster than `n`

- if there are `100`

values, `4950`

comparisons are needed, while `200`

values requires `19900`

comparisons. For series covering a long period of time or with a great deal of granularity, this algorithm might be too slow even for a fast computer.

Instead of comparing every value with every other value, we can exploit the sequential requirement and make only `n - 1`

comparisons:

```
var peak = 0;
var n = prices.length
for (var i = 1; i < n; i++){
dif = prices[peak] - prices[i];
peak = dif < 0 ? i : peak;
maxDrawdown = maxDrawdown > dif ? maxDrawdown : dif;
}
```

Iterating over each index `i`

of the series in order, the maximum decline ending at point `i`

will start at the highest point of the series so far. While passing over the series we keep track of two numbers - the `peak`

of the series and the `maxDrawdown`

in price between `peak`

and `i`

.

The speed difference between the two algorithms is proportional to the number of prices. Calculating drawdown with the second approach on a series with `100`

values takes `99`

comparisons instead of `4950`

, which is `50`

(`100/2`

) times faster. A series with `200`

values requires `199`

comparisons instead of `19900`

, which is `100`

(`200/2`

) times faster. In general, since the first approach requires `n*(n - 1)/2`

comparisons for a series with `n`

values and the second `n - 1`

comparisons, the second approach will be `n/2`

times faster.