Walk me through how you would analyze the time and space complexity of a piece of code.

Work out how the runtime grows as the input grows, then drop constants and lower order terms. Read the code structure: sequential blocks add, nested loops multiply, and recursive calls follow the recurrence. Space is the extra memory you allocate beyond the input, including the call stack. State the worst case by default, and call out the average case separately if they differ meaningfully.

I start by naming n, because half the confusion in these conversations comes from two people measuring different things. Then I read the code structurally. Sequential blocks add, so the biggest one wins; nested loops multiply; a recursive call becomes a recurrence I can either expand or recognize. For space I count anything I allocate beyond the input, and I always include the call stack, which is the bit people forget with recursion. A concrete example: I had a function that looked linear because it was one loop over a list of orders, but inside it we called a helper that looked a record up by id in a list. That lookup was linear, so the real cost was quadratic, and it only showed up once one customer hit about forty thousand orders. We swapped the list for a dictionary keyed by id and the endpoint went from around nine seconds to under two hundred milliseconds. So my rule is to look inside every call, not just the loops I can see.