Your code got TLE? Let's find out why.

Diagnose. Treat. Cure. Never TLE again.
Paste your slow code below. TLE Doctor examines it like a patient, explains its time complexity in simple words, points to the exact part that is too slow, and prescribes the fix — like a senior sitting beside you at a contest.

🔑 Step 1 — Connect the AI (one time only)

Get it free from Google AI Studio → "Create API key". Your key is saved only in your own browser — never uploaded anywhere else. No key yet? Click "Try a sample diagnosis" below to see how the app works.

💻 Step 2 — Paste your code

1

0 lines · 0 characters

💡 Want to think first? Take a hint instead of the full cure:

Hints unlock in order — that's how real learning works. The full diagnosis is always one click above.

📋 Diagnosis Report

🎯 Example Gallery — try a patient

One click loads the code into Step 2. Then press Diagnose (or peek at the sample diagnosis, which needs no key).

❌ Bubble Sort

C++O(n²)

The classic first sorting algorithm every beginner writes — and the first one to TLE at n = 100000.

❌ Fibonacci, Plain Recursion

PythonO(2ⁿ)

Looks tiny and innocent. Secretly recomputes the same answers millions of times.

❌ Building a String in a Loop

PythonO(n²)

Adding to a string piece by piece copies the whole string every single time.

✅ Two Sum, Optimised

C++O(n)

A healthy patient! Diagnose it and watch the Doctor give a ✅ PASS verdict for once.

📚 TLE Patterns Library

The usual suspects behind most TLEs. Learn to recognise them on sight — no AI needed, this page is pure experience.

🔁 Nested Loops

O(n²)

TLEs when: n > 10⁴

Symptom: a loop inside a loop, both running over the same data.

Cure: hash map, two pointers, or sort + binary search.

🔍 Linear Search Inside a Loop

O(n²)

TLEs when: n > 10⁴

Symptom: for every element, scanning the whole array to find or count something — like count() inside a loop.

Cure: build a frequency map or set once, then every lookup is O(1).

🐇 Recursion Without Memoisation

O(2ⁿ)

TLEs when: n > 25

Symptom: fib-style recursion that recomputes the same subproblems again and again.

Cure: memoisation (cache the answers) or a bottom-up DP table.

🧵 String Concatenation in a Loop

O(n²)

TLEs when: n > 10⁵

Symptom: s += piece in Python/Java — every addition copies the whole string built so far.

Cure: collect pieces in a list, then join once at the end.

🐌 Slow Input / Output (C++)

I/O bottleneck

TLEs when: input > 10⁵ lines

Symptom: cin/cout without fast I/O, or endl on every line (endl flushes every time!).

Cure: ios::sync_with_stdio(false); cin.tie(nullptr); and '\n' instead of endl.

🔃 Sorting Inside a Loop

O(n² log n)

TLEs when: n > 10³

Symptom: calling sort() again after every insertion or for every query.

Cure: sort once before the loop, or use a balanced BST / priority queue.

🧮 Complexity Calculator — will it TLE?

No AI here — just the maths judges live by: roughly 10⁸ simple operations per second.