feat: add Product of Array Except Self

Author: wislertt

.templates/leetcode/json/product_of_array_except_self.json

@@ -0,0 +1,43 @@
+{
+    "problem_name": "product_of_array_except_self",
+    "solution_class_name": "Solution",
+    "problem_number": "238",
+    "problem_title": "Product of Array Except Self",
+    "difficulty": "Medium",
+    "topics": "Array, Prefix Sum",
+    "tags": ["grind-75"],
+    "readme_description": "Given an integer array `nums`, return an array `answer` such that `answer[i]` is equal to the product of all the elements of `nums` except `nums[i]`.\n\nThe product of any prefix or suffix of `nums` is guaranteed to fit in a 32-bit integer.\n\nYou must write an algorithm that runs in O(n) time and without using the division operation.",
+    "readme_examples": [
+        { "content": "```\nInput: nums = [1,2,3,4]\nOutput: [24,12,8,6]\n```" },
+        { "content": "```\nInput: nums = [-1,1,0,-3,3]\nOutput: [0,0,9,0,0]\n```" }
+    ],
+    "readme_constraints": "- 2 <= nums.length <= 10^5\n- -30 <= nums[i] <= 30\n- The input is generated such that answer[i] is guaranteed to fit in a 32-bit integer.",
+    "readme_additional": "**Follow up:** Can you solve the problem in O(1) extra space complexity? (The output array does not count as extra space for space complexity analysis.)",
+    "solution_imports": "",
+    "solution_methods": [
+        {
+            "name": "product_except_self",
+            "parameters": "nums: list[int]",
+            "return_type": "list[int]",
+            "dummy_return": "[]"
+        }
+    ],
+    "test_imports": "import pytest\nfrom leetcode_py.test_utils import logged_test\nfrom .solution import Solution",
+    "test_class_name": "ProductOfArrayExceptSelf",
+    "test_helper_methods": [
+        { "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }
+    ],
+    "test_methods": [
+        {
+            "name": "test_product_except_self",
+            "parametrize": "nums, expected",
+            "parametrize_typed": "nums: list[int], expected: list[int]",
+            "test_cases": "[([1, 2, 3, 4], [24, 12, 8, 6]), ([-1, 1, 0, -3, 3], [0, 0, 9, 0, 0]), ([2, 3, 4, 5], [60, 40, 30, 24])]",
+            "body": "result = self.solution.product_except_self(nums)\nassert result == expected"
+        }
+    ],
+    "playground_imports": "from solution import Solution",
+    "playground_test_case": "# Example test case\nnums = [1, 2, 3, 4]\nexpected = [24, 12, 8, 6]",
+    "playground_execution": "result = Solution().product_except_self(nums)\nresult",
+    "playground_assertion": "assert result == expected"
+}

Makefile

@@ -1,5 +1,5 @@
 PYTHON_VERSION = 3.13
-PROBLEM ?= add_binary
+PROBLEM ?= product_of_array_except_self
 FORCE ?= 0
 COMMA := ,
 

leetcode/product_of_array_except_self/README.md

@@ -0,0 +1,39 @@
+# Product of Array Except Self
+
+**Difficulty:** Medium
+**Topics:** Array, Prefix Sum
+**Tags:** grind-75
+
+**LeetCode:** [Problem 238](https://leetcode.com/problems/product-of-array-except-self/description/)
+
+## Problem Description
+
+Given an integer array `nums`, return an array `answer` such that `answer[i]` is equal to the product of all the elements of `nums` except `nums[i]`.
+
+The product of any prefix or suffix of `nums` is guaranteed to fit in a 32-bit integer.
+
+You must write an algorithm that runs in O(n) time and without using the division operation.
+
+## Examples
+
+### Example 1:
+
+```
+Input: nums = [1,2,3,4]
+Output: [24,12,8,6]
+```
+
+### Example 2:
+
+```
+Input: nums = [-1,1,0,-3,3]
+Output: [0,0,9,0,0]
+```
+
+## Constraints
+
+- 2 <= nums.length <= 10^5
+- -30 <= nums[i] <= 30
+- The input is generated such that answer[i] is guaranteed to fit in a 32-bit integer.
+
+**Follow up:** Can you solve the problem in O(1) extra space complexity? (The output array does not count as extra space for space complexity analysis.)

leetcode/product_of_array_except_self/__init__.py

@@ -0,0 +1,79 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "imports",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from solution import Solution"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "setup",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Example test case\n",
+    "nums = [1, 2, 3, 4]\n",
+    "expected = [24, 12, 8, 6]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "execute",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[24, 12, 8, 6]"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "result = Solution().product_except_self(nums)\n",
+    "result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "test",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "assert result == expected"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "leetcode-py-py3.13",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.13.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

leetcode/product_of_array_except_self/playground.ipynb

@@ -0,0 +1,25 @@
+class Solution:
+    # Time: O(n)
+    # Space: O(1)
+    def product_except_self(self, nums: list[int]) -> list[int]:
+        # Example: nums = [1, 2, 3, 4]
+        # Expected output: [24, 12, 8, 6]
+
+        n = len(nums)
+        result = [1] * n  # [1, 1, 1, 1]
+
+        # Left pass: result[i] = product of all elements to the left of i
+        # nums:   [1, 2, 3, 4]
+        # result: [1, 1, 2, 6] (left products)
+        for i in range(1, n):
+            result[i] = result[i - 1] * nums[i - 1]
+
+        # Right pass: multiply by product of all elements to the right of i
+        # right products: [24, 12, 4, 1]
+        # result: [1*24, 1*12, 2*4, 6*1] = [24, 12, 8, 6]
+        right = 1
+        for i in range(n - 1, -1, -1):
+            result[i] *= right
+            right *= nums[i]
+
+        return result

leetcode/product_of_array_except_self/solution.py

@@ -0,0 +1,38 @@
+import pytest
+
+from leetcode_py.test_utils import logged_test
+
+from .solution import Solution
+
+
+class TestProductOfArrayExceptSelf:
+    def setup_method(self):
+        self.solution = Solution()
+
+    @pytest.mark.parametrize(
+        "nums, expected",
+        [
+            ([1, 2, 3, 4], [24, 12, 8, 6]),
+            ([-1, 1, 0, -3, 3], [0, 0, 9, 0, 0]),
+            ([2, 3, 4, 5], [60, 40, 30, 24]),
+            # Edge cases
+            ([1, 1], [1, 1]),  # Minimum length
+            ([5, 2], [2, 5]),  # Two elements
+            ([0, 0], [0, 0]),  # All zeros
+            ([1, 0], [0, 1]),  # Single zero
+            ([0, 1, 2], [2, 0, 0]),  # Zero at start
+            ([1, 2, 0], [0, 0, 2]),  # Zero at end
+            # Negative numbers
+            ([-1, -2], [-2, -1]),
+            ([-1, -2, -3], [6, 3, 2]),
+            ([1, -2, 3], [-6, 3, -2]),
+            # All ones
+            ([1, 1, 1, 1], [1, 1, 1, 1]),
+            # Large numbers
+            ([10, 3, 5, 6, 2], [180, 600, 360, 300, 900]),
+        ],
+    )
+    @logged_test
+    def test_product_except_self(self, nums: list[int], expected: list[int]):
+        result = self.solution.product_except_self(nums)
+        assert result == expected