Let's see how programmers evaluate fast and slow algorithms. Since the topic is pretty boring, we'll use silly cat examples.
Constant time: O(1)
This is your best option. The algorithm speed does not depend on the number of cats.
🐾 Example
You are the lucky owner of N
cats. Every kitten knows their name. If you call "Felix!", only one will come running, and the rest of the N-1
fluffs don't care.
Logarithmic time: O(log n)
On N
cats the algorithm completes in log(N)
steps. It's fast! 1,000,000 kittens → 20 operations total.
🐾 Example
Cat's bowls are arranged alphabetically. When you adopt a new cat, the place for its bowl can be found in log(N)
steps.
Linear time: O(n)
On N
cats the algorithm completes in N
steps. It means that every time you have to traverse all cats. Not great, not terrible.
🐾 Example
Your kittens rebelled and stopped responding to nicknames. Now you have to look through N
fluffs to find the right one.
Log-linear time: O(n log n)
On N
cats the algorithm completes in N
× log(N)
steps. This is slower than in linear time, but not by much (the logarithm of N
is much smaller than N
, remember?).
🐾 Example
Waiting for guests, you decided to seat kittens in the order of their size. The quick sort algorithm will handle this in N
× log(N)
steps.
Next in line, we have lazy polynomial cats and snail-speed superpolynomial ones.
Quadratic time: O(n²)
On N
cats the algorithm completes in N²
steps. So slow.
🐾 Example
Your competitor claims that his N
kittens are smoother and happier than yours. A special commission will compare the cats in pairs and make a fair verdict. You will need ~ N²
comparisons.
Polynomial time: O(nᵏ)
On N
cats the algorithm completes in N³
steps, N⁴
steps, N⁵
steps, or even longer. Ugh. Don't be like that.
🐾 Example
Photoshoot! Each of the N
kittens will be photographed in pairs with others, and the photographer takes N
pictures for each pair. N
× N
× N
≃ N³
steps.
Polynomial algorithms are not famous for their speed. But compared to superpolynomial ones, they are as fast as a Flash. Sadly, the only "super" part of superpolynomial algorithms is a name. Let me show you.
Exponential time: O(2ⁿ)
On N
cats the algorithm completes in 2ⁿ
steps. It's a long time, you're probably not gonna wait.
🐾 Example
Kittens are going to the cat show. Everyone will be weighed and rated in stars. But the cat transport can handle a maximum of X kilograms (or pounds). How to choose the most stellar cast? The answer will require 2ⁿ
steps.
Factorial time: O(n!)
On N
cats the algorithm completes in N
×(N-1)
×(N-2)
×... × 1
steps. This is crazy! With 20 cats it's already a couple of quintillion operations.
🐾 Example
Kittens spread out across the apartment. You want to pet everyone, but you're lazy and don't like walking. What is the shortest route to visit all fluffs? This is ~ N!
comparisons.
Summary
Here are the algorithms we've covered:
- Constant
O(1)
- Logarithmic
O(log n)
- Linear
O(n)
- Log-Linear
O(n log n)
- Quadratic
O(n²)
- Polynomial
O(nᵏ)
- Exponential
O(2ⁿ)
- Factorial
O(n!)
A constant algorithm is always the best option, and a logarithmic one is almost always. Linear and polynomial ones are more complex — it all depends on the task with them. Sometimes it's a shame to choose O(n)
, and sometimes O(n²)
is a huge success.
O(2ⁿ)
and O(n!)
are insanely slow. So in practice, people often use suboptimal but fast algorithms.
Follow @ohmypy on Twitter to keep up with new posts 🚀
Top comments (0)