How It Works
TC Getter is a free online Python time complexity analyzer that shows Big-O notation for your code instantly in the browser.
- Paste or type Python code — The editor supports for/while loops, list comprehensions, generator expressions, and function definitions.
- Automatic AST parsing — Code is parsed into an Abstract Syntax Tree via tree-sitter (WebAssembly). Accurate structural analysis, not regex guessing.
- See Big-O annotations inline — Badges like
O(1),O(n),O(n²)appear next to each line as you type. - Function-level complexity — Overall function complexity is computed from maximum loop nesting depth. Two nested for loops =
O(n²).
No sign-up, no backend, no data sent anywhere. Runs entirely client-side via WebAssembly.
What Is Time Complexity?
Time complexity measures how the number of operations an algorithm performs grows with input size. It is the standard way to evaluate algorithm efficiency, expressed using Big-O notation.
A for loop over n elements runs in O(n) — linear time. Two nested loops over n elements give O(n²) — quadratic time. Understanding this is crucial for writing efficient code, especially for coding interviews and competitive programming.
Big-O notation describes the worst-case growth rate and ignores constants. O(2n) simplifies to O(n), and O(n² + n) simplifies to O(n²) — only the dominant term matters at scale.
Big-O Notation Quick Reference
Common time complexities from fastest to slowest, with Python examples:
| Big-O | Name | Python Example |
|---|---|---|
| O(1) | Constant | dict[key], list.append(), len() |
| O(log n) | Logarithmic | bisect.bisect(), binary search |
| O(n) | Linear | for x in list, x in list, max() |
| O(n log n) | Linearithmic | sorted(), list.sort(), merge sort |
| O(n²) | Quadratic | Nested loops, bubble sort, selection sort |
| O(n³) | Cubic | Triple nested loops, naive matrix multiplication |
Time Complexity of Python Built-in Operations
A quick reference for the time complexity of common Python data structure operations:
| Operation | List | Dict / Set |
|---|---|---|
| Access by index / key | O(1) | O(1) |
Search (in) |
O(n) | O(1) |
| Insert / append | O(1)* | O(1) |
| Delete | O(n) | O(1) |
| Sort | O(n log n) | — |
len() |
O(1) | O(1) |
* amortized — occasional resizes cost O(n) but average out to O(1) per operation.
How Nested Loops Affect Time Complexity
A common question in algorithm analysis: how do nested loops affect time complexity? Each level of nesting multiplies the complexity.
- Single loop over n elements →
O(n) - Two nested loops, each over n elements →
O(n²) - Three nested loops →
O(n³)
TC Getter detects nesting depth automatically. Paste a bubble sort or selection sort and see O(n²) on the function with O(n) on each loop. For triple-nested code like matrix multiplication, it reports O(n³).
Dependent loops (where the inner range depends on the outer variable, e.g., for j in range(i)) still give O(n²) overall, even though the exact count is n(n-1)/2. Big-O drops the constant.
Frequently Asked Questions
What is time complexity?
Time complexity describes how the runtime of an algorithm grows as the input size increases. It is expressed using Big-O notation — for example, O(n) means the runtime grows linearly with the input size, while O(n²) means it grows quadratically.
What is Big-O notation?
Big-O notation is a mathematical notation that describes the upper bound of an algorithm's growth rate. Common complexities include O(1) constant, O(log n) logarithmic, O(n) linear, O(n log n) linearithmic, O(n²) quadratic, and O(n³) cubic.
How do I find the time complexity of my Python code?
Paste your Python code into the editor above. TC Getter will automatically parse it into an Abstract Syntax Tree, identify loops, comprehensions, and function definitions, and display Big-O annotations inline next to each relevant line — all within milliseconds.
Does this tool send my code to a server?
No. TC Getter runs entirely in your browser using WebAssembly. Your code never leaves your machine — there is no backend server involved. This makes it safe to use with proprietary or sensitive code.
How do nested loops affect time complexity?
Each level of loop nesting multiplies the complexity. A single loop is O(n), two nested loops are O(n²), and three nested loops are O(n³). TC Getter detects nesting depth automatically and annotates functions accordingly.
What Python constructs does TC Getter analyze?
TC Getter analyzes for loops, while loops, list comprehensions, generator expressions, and function definitions. It computes per-line complexity and overall function-level complexity based on maximum nesting depth.
What is the difference between time complexity and space complexity?
Time complexity measures how the number of operations grows with input size. Space complexity measures how the memory usage grows. For example, creating a copy of a list is O(n) space, while sorting it in-place is O(1) extra space. TC Getter currently focuses on time complexity analysis.
Can I use this to prepare for coding interviews?
Yes. Paste your LeetCode or HackerRank solution into the editor and instantly see the Big-O complexity of every loop and function. This helps you verify whether your solution meets the expected time complexity before submitting.
How is this different from cyclomatic complexity?
Cyclomatic complexity counts the number of independent execution paths through your code (branches, conditions). Time complexity measures how the runtime scales with input size. They answer different questions — TC Getter focuses on time complexity (Big-O), which is what matters for algorithm efficiency.
How to Calculate Big-O Step by Step
Here's a manual approach to finding the time complexity of any code:
- Identify the loops — Find every
for,while, and comprehension. Each loop that iterates over the input contributesO(n). - Check for nesting — If loops are nested (one inside another), multiply their complexities. Two nested
O(n)loops giveO(n²). - Identify built-in calls —
sorted()and.sort()areO(n log n).x in listisO(n).x in setisO(1). - Take the dominant term — If a function has an
O(n)loop followed by anO(n²)section, the overall complexity isO(n²). - Drop constants —
O(2n)becomesO(n).O(n²/2)becomesO(n²). Only the growth rate matters.
Or simply paste your code into TC Getter and let the analyzer do the work automatically.