In coding interviews, solving the problem is only part of the evaluation. Interviewers also expect you to justify how your solution scales as input size grows.
Explain how you would discuss the time complexity of your solution after implementing it. In your answer, address:
Focus on practical interview-style analysis rather than formal proofs. The interviewer expects you to walk through how to derive Big O for a typical algorithm, explain why one term dominates others, and mention common pitfalls such as ignoring hidden work inside operations or confusing time and space complexity.
Time complexity is driven by the operations that grow fastest with input size. Constant-time setup work matters less than repeated work inside loops or recursive calls.
for x in nums:
total += x # repeated n times, so O(n)
When one loop runs inside another over the same input, the total work is often multiplicative. Two full nested loops over n elements usually lead to O(n^2) time.
for i in range(n):
for j in range(n):
count += 1
Hash table operations such as dictionary lookup are typically treated as O(1) average time in interviews. However, a strong answer notes that worst-case behavior can degrade if many collisions occur.
seen = {}
if target in seen:
return True
For recursion, analyze both the amount of work per call and the number of calls. A recursive solution can be linear, logarithmic, or exponential depending on how the problem size changes.
def dfs(node):
if not node:
return
dfs(node.left)
dfs(node.right)
Interviewers want a concise explanation, not just a final label. A good response states the traversal pattern, counts how many times each element is processed, and then gives the resulting complexity.
