Time vs Space

Algorithms often have more than one valid solution with different tradeoffs — the same problem, solved faster by using more memory, or solved with less memory by taking more time. Detecting a duplicate in a list is a clean example you've already partially seen (in the Data Structures course's Hash Tables module and Python's Performance module):

def has_duplicate_extra_space(nums):
    seen = set()          # extra O(n) memory in the worst case
    for n in nums:
        if n in seen:
            return True     # O(1) average lookup -> O(n) total time
        seen.add(n)
    return False

Neither approach is universally "better" — it depends on what's scarce:

• Hash set: O(n) time, O(n) extra space. Best when memory is plentiful and speed matters most.
• Sort-then-scan: O(n log n) time, no significant extra space beyond the sort itself (and sorted() avoids mutating the original list, at the cost of a copy — sorting the list IN PLACE with .sort() instead would use less memory still).

This tradeoff — trading memory for speed, or speed for memory — shows up constantly: caching (memory for speed), streaming algorithms (speed/ correctness for memory), compression (time for space). Recognizing "this is a time/space tradeoff" is often the first step to picking the right one for your actual constraints.