Post

I still don't understand why we can have O(n) but not O(2n) or O(n+1)

Nothing is really stopping you from writing O(2n) if you really wanted to, but you won't find many people doing it. The idea is that as N approaches infinity, what is the most significant term? And in this case it is N itself. The multiplication doesn't change the _growth_ of the function.

> Note: On some browsers, you might experience bars taking a lot longer than they should It's true! I wonder why this happens. This could be a really fun rabbit hole

This is awesome! I love interactive articles! To add to the inaccuracy/variability of loop timing that you called out, here's a technique that I think helps with discounting the loop overhead: ates.dev/posts/2025-0...

I only call sum once so I don’t think this technique applies. I’m running the code on a pool of web worker threads so there’s a bunch of overhead in posting messages back and forth and then with OS-level thread scheduling.

And of course despite proof reading it no fewer than a dozen times personally, and having 4 calls with others to proof read it 1:1 with them, and sending it to maybe half a dozen other people over the last 2 months, someone points out within minutes an incorrect code example. 🫠 Fixed now.

found a little bug on zen browser (firefox) otherwise, amazing resource!

Lol! That’s really funny. Given that it works in Chrome, Safari, and Firefox I’m inclined to think it’s probably a Zen bug. 🤔

Great post, as expected! 💯 I wonder about the buildList example, though. The time complexity analysis of the function seems to omit the .join() operation, which makes the big O value either O(n^2+n) or O(2n), right?

Technically yes, but big O only includes the most significant contributor to the function’s growth, and then the smallest variant of it. It’s very confusing. So O(n^2+n) is just O(n^2). The idea is to say “the order of growth is no less than this.” I do sometimes see people being more specific.

Right. I’ve seen examples with multiple components, signalling that an algorithm has multiple expensive operations to it (for example, in a gamedev book). In a case of two linear components, there is no clear winner, I guess?

nice post! i love the interactive graphs. there are a few things aren't correct here though. this is false. it's a common misconception, but it's still wrong. O and Θ can both be used to describe worst-case or average case complexities.

Corrected!

sorry, but that's still incorrect. Θ(n^2) is not about best case complexity, it means that the complexity of the algorithm is equivalent to n^2, whereas with O, it is only "at most as slow as" n^2, but it could be faster. so bubble sort's worst case complexity *is* in Θ(n^2)

the difference is that O is an upper bound (so e.g. n ∈ O(n^2)), whereas Θ is an upper *and lower* bound (f ∈ Θ(g) means f ∈ O(g) *and* g ∈ O(f)) in fact, you used O notation yourself to describe the *expected* complexity of hash sets! (the worst-case complexity is linear)

This was on purpose, I wanted to avoid talking about amortisation and figured this little fib wasn’t the end of the world.

this is another misconception. O(1) complexity only means that a function is *bounded* by a constant. it can still vary in fact, if you have a time complexity like T(n) = Σ_(i=1)^n (1/2)^i then T is strictly monotonically increasing, but it is still in O(1), because it will never exceed 2.

I’ve been programming for years, but I don’t have a math background so Big O notation always kinda went over my head (despite reading many articles on it when I was on the LeetCode grind). This finally helped it click for me - thank you for making this article! The illustrations are sooo nice

How do we handle progressive enhancement and people who have prefer to have reduced motion?

Honestly, I don’t. I have in the past made animations less motion heavy if the user has specific prefer-reduced-motion but no one has ever made a comment in favour of it or complaining when it’s missing so I’ve not done it for a few posts. Not a great policy but happy to work with people who need it

n(n+1)/2 isn't from Gauss, it was well-known way before him, but according to the legend he found it by himself at a very young age

Who discovered it?

en.wikipedia.org/wiki/Triangu... Pythagoreans

Loving the interactive demos! In the `buildList` example, there’s no need to stop using `for-of` just to get access to the index. Try: for (const [index, item] of items.entries()) { output.push(`Item ${index + 1}: ${items[index]}`); } Smaller diff, might be easier to follow. WDYT?

I avoided this because it’s a JS-ism some folks might not be familiar with. I felt the index example was a bit more widely accessible ans achieved the same goal. I call out Object.entries under the last code example. 🙏

I saw that, but the example I gave uses Array.prototype.entries (not Object.entries).

Is your logo missing on this page? It is present on the other pages, but on this one I don't see a way to navigate back to the home page 🤷🏻‍♂️

Incredible as always, Sam! 🫶

Great primer! Thanks for putting the work in! Small correction

I’ve always found Big O tricky, but these data visualizations made it click much more for me! Wish I’ve read this before grinding theory for Leetcode 😅

Another fantastic post 😁 I love how well you distill these concepts into easy to understand and interactive articles. Looking forward to sharing this in my newsletter this week 😁