MARISSA MOLEJON | OCT2025-1 | Module-Complexity | Sprint 1 | Refactor/python complexity analysis - #3

Summary

Analyzes the time and space complexity of all four Sprint 1 Python
functions, documents the findings in docstrings, and refactors the
functions where the complexity could be improved. Companion PR to the
JavaScript version of this work.

Changes made

All four functions now have complete docstrings documenting Time
Complexity, Space Complexity, and Optimal Time Complexity.

Testing

All existing tests pass unchanged for every function - no test files
were modified.

Ran locally via python3 -m pytest -v in each function's folder — all
green (2, 3, 3, and 4 tests respectively).

Learning points

• find_common_items was the standout case: a nested loop (O(n·m)) plus
  an i not in common_items check on a growing list (O(k) per check)
  compounded into roughly O(n·m·k) — worse than a "plain" nested loop,
  and not obvious without tracing through what in costs on a list
  versus a set.
• Removing dead code (the empty-list guard in calculate_sum_and_product)
  is itself a valid refactor — it doesn't change complexity, but it
  removes a second source of truth that could drift out of sync with the
  real logic.
• Applied the same JS -> Python translation of the "seen set" pattern
  across has_pair_with_sum and remove_duplicates, reinforcing that the
  algorithmic idea (O(n²) -> O(n) via a hash-based lookup) is
  language-independent, even though the syntax isn't.

Checklist

• All tests pass
• Complexity documented for every function
• No test files modified
• Self-reviewed for readability, naming, and duplication