Complexity Comparison Generator
Big-O deliberately ignores constant factors, and this shows exactly what that costs. An n log n algorithm with a twenty-times overhead loses to a plain n-squared one until the input gets big enough — and "big enough" is a number you can compute rather than a hand-wave. Sometimes the crossover is at n = 8; sometimes it is past any size you will ever meet, and then the asymptotically worse algorithm is simply the right choice.
What this generator does
Tabulates operation counts for two algorithms across doubling input sizes, one growing as n log n with a constant overhead and one as n squared with none, and identifies the size at which the first overtakes the second.
How to use this tool
- Set how much overhead the better-growing algorithm carries.
- Read down the table and find where the winner changes.
- Push the overhead up and watch the crossover move right.
- Notice when it disappears from the range entirely.
Understanding the controls
- Constant overhead
- How many times more work each step of the better-growing algorithm costs. Between 2 and 200 — at the high end the crossover leaves the table entirely.
Common use cases
- Deciding whether an asymptotically better algorithm is worth it
- Showing why constant factors matter at real input sizes
- Teaching what big-O does and does not promise
- Justifying a simple algorithm for small inputs
- Comparing growth rates without writing benchmarks
How this generator works
Each cell is the constant times the growth function at that size, so the table is arithmetic rather than measurement. The check recomputes every cell from the growth function it claims, requires the counts to be non-decreasing, and confirms the stated crossover is the first size where the order changes.
Randomness and fairness
Nothing here is random. The same overhead always produces the same table, which is why there is no seed.
For how randomness is produced across the whole site, see how Generate Random works.
Limitations and good to know
- Compares n log n against n squared only; other pairings would need different growth functions.
- Operation counts are abstract — real performance depends on cache behaviour, memory and constant factors this cannot see.
- Sizes stop at 1,024, so a very large overhead has no crossover in range.
- Nothing is measured; this is arithmetic on growth functions, not a benchmark.
- Tables are not stored between visits.
Privacy and your data
The table is computed in your browser from the number you enter. Nothing is transmitted or stored.
Related generators
- Binary Search Scenario GeneratorSorted lists with the full binary search trace, every step's range shown, and the logarithmic bound as the check.
- Sorting Algorithm Trace GeneratorAn array, an algorithm, and the state after every pass, with the comparison and move counts that distinguish the three.
- Topological Sort Challenge GeneratorDependency sets with a valid order and a count of how many valid orders exist in total.
- Hash Table Scenario GeneratorKeys distributed into buckets by modulo hashing, with collisions, chain lengths and empty buckets all recounted from the table.