Add solution for product array except self

Author: kwnna15

array/product-array/README.md

@@ -0,0 +1,35 @@
+# 238. Product of Array Except Self
+
+## Description
+See https://leetcode.com/problems/product-of-array-except-self/description/
+
+## Problem
+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.
+
+## 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 <= 105
+-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.)

array/product-array/productarray.py

@@ -0,0 +1,15 @@
+def product_array(nums: list[int]) -> list[int]:
+    n = len(nums)
+    output = [1] * n
+
+    left = 1
+    for i in range(n):
+        output[i] *= left
+        left *= nums[i]
+
+    right = 1
+    for i in range(n - 1, -1, -1):
+        output[i] *= right
+        right *= nums[i]
+
+    return output

array/product-array/productarray_test.py

@@ -0,0 +1,26 @@
+from productarray import product_array
+
+
+def test_example_1():
+    nums = [1, 2, 3, 4]
+    assert product_array(nums) == [24, 12, 8, 6]
+
+
+def test_example_2():
+    nums = [5, 6, 2, 3]
+    assert product_array(nums) == [36, 30, 90, 60]
+
+
+def test_example_3():
+    nums = [1, 2, 3, 4, 5]
+    assert product_array(nums) == [120, 60, 40, 30, 24]
+
+
+def test_example_4():
+    nums = [10, 3, 5, 6, 2]
+    assert product_array(nums) == [180, 600, 360, 300, 900]
+
+
+def test_example_5():
+    nums = [1, 1, 1, 1]
+    assert product_array(nums) == [1, 1, 1, 1]

array/reverse-vowels/README.md

@@ -1,32 +1,32 @@
-# 605. Can Place Flowers
+# 345. Reverse Vowels of a String
 
 ## Description
-See https://leetcode.com/problems/can-place-flowers/description/
+See https://leetcode.com/problems/reverse-vowels-of-a-string/description/
 
 ## Problem
-You have a long flowerbed in which some of the plots are planted, and some are not. However, flowers cannot be planted in adjacent plots.
+Given a string `s`, reverse only all the vowels in the string and return it.
 
-Given an integer array `flowerbed` containing `0`'s and `1`'s, where `0` means empty and `1` means not empty, and an integer `n`, return `true` if `n` new flowers can be planted in the `flowerbed` without violating the no-adjacent-flowers rule and `false` otherwise.
+The vowels are `'a'`, `'e'`, `'i'`, `'o'`, and `'u'`, and they can appear in both lower and upper cases, more than once.
 
 ## Example 1
 
 ```
-Input: flowerbed = [1,0,0,0,1], n = 1
-Output: true
+Input: s = "IceCreAm"
+Output: "AceCreIm"
+Explanation:
+The vowels in s are ['I', 'e', 'e', 'A']. On reversing the vowels, s becomes "AceCreIm".
 ```
 
 ## Example 2
 
 ```
-Input: flowerbed = [1,0,0,0,1], n = 2
-Output: false
+Input: s = "leetcode"
+Output: "leotcede"
 ```
 
 ## Constraints
 
 ```
-1 <= flowerbed.length <= 2 * 104
-flowerbed[i] is 0 or 1.
-There are no two adjacent flowers in flowerbed.
-0 <= n <= flowerbed.length
+1 <= s.length <= 3 * 105
+s consist of printable ASCII characters.
 ```