Enter your Big O notation (like O(n²) or O(log n)) and input size (n) to estimate how many operations your algorithm performs. Choose from common complexities — O(1), O(log n), O(n), O(n log n), O(n²), O(n³), O(2ⁿ), O(n!) — and see the estimated operation count, a relative performance rating, and a chart comparing growth curves across complexities.
Estimated Operations
--
Estimated Execution Time
--
Performance Rating
--
Complexity Class
--
Big O notation is a mathematical system used to describe how the runtime or memory usage of an algorithm scales as the input size grows. It focuses on the worst-case scenario and ignores constants, helping developers compare algorithm efficiency independently of hardware. For example, O(n²) means execution time grows quadratically with input size.
You select a Big O complexity class (e.g. O(n log n)), enter your input size n, and choose an approximate CPU speed. The calculator applies the corresponding mathematical formula to estimate the total number of operations and converts that to an estimated real-world execution time in milliseconds.
Time complexity measures how the number of computational steps grows with input size, while space complexity measures how memory usage grows. An algorithm can be fast (good time complexity) but memory-hungry (poor space complexity), or vice versa. Big O notation is used to express both.
O(1) constant time is the fastest — the algorithm takes the same time regardless of input size. O(log n) is next, followed by O(√n), O(n), O(n log n), O(n²), O(n³), O(2ⁿ), and O(n!) which is the slowest and becomes infeasible very quickly even for small inputs.
Exponential growth means the operation count doubles with every increase of 1 in n. At n=30, that's already over 1 billion operations. At n=50, it exceeds a quadrillion. Algorithms with O(2ⁿ) complexity (like naive recursive Fibonacci) are generally impractical beyond very small inputs.
Big O gives a relative estimate, not an exact measurement. Real execution time also depends on CPU speed, memory access patterns, compiler optimizations, constant factors, and the specific input data. This calculator uses a simplified model to give you a ballpark figure useful for comparing algorithms.
O(n log n) is the complexity of efficient comparison-based sorting algorithms like Merge Sort, Heap Sort, and Timsort. It means the algorithm does slightly more than linear work — roughly n multiplied by the number of times you can halve n. For n=1,000,000, that's about 20 million operations, which is very manageable.
Absolutely. This tool is designed to help students and developers build intuition about how algorithm efficiency scales. By comparing different complexities side by side at the same input size, you can clearly see why choosing the right algorithm matters enormously as data grows.