Solve 238 - Product of Array Except Self (#11)

Author: terenceponce

README.md

@@ -11,5 +11,6 @@ This is a monorepo containing my solutions to LeetCode problems written in vario
 - 1 - Two Sum - [Notes](notes/0001_two_sum.md) | [Elixir](elixir/lib/solutions/0001_two_sum/two_sum.ex) | [Ruby](ruby/lib/solutions/0001_two_sum/two_sum.rb)
 - 49 - Group Anagrams - [Notes](notes/0049_group_anagrams.md) | [Elixir](elixir/lib/solutions/0049_group_anagrams/group_anagrams.ex) | [Ruby](ruby/lib/solutions/0049_group_anagrams/group_anagrams.rb)
 - 217 - Contains Duplicate - [Notes](notes/0217_contains_duplicate.md) | [Elixir](elixir/lib/solutions/0217_contains_duplicate/contains_duplicate.ex) | [Ruby](ruby/lib/solutions/0217_contains_duplicate/contains_duplicate.rb)
+- 238 - Product of Array Except Self - [Notes](notes/0238_product_of_array_except_self.md) | [Elixir](elixir/lib/solutions/0238_product_of_array_except_self/product_of_array_except_self.ex) | [Ruby](ruby/lib/solutions/0238_product_of_array_except_self/product_of_array_except_self.rb)
 - 242 - Valid Anagram - [Notes](notes/0242_valid_anagram.md) | [Elixir](elixir/lib/solutions/0242_valid_anagram/valid_anagram.ex) | [Ruby](ruby/lib/solutions/0242_valid_anagram/valid_anagram.rb)
 - 347 - Top K Frequent Elements - [Notes](notes/0347_top_k_frequent_elements.md) | [Elixir](elixir/lib/solutions/0347_top_k_frequent_elements/top_k_frequent_elements.ex) | [Ruby](ruby/lib/solutions/0347_top_k_frequent_elements/top_k_frequent_elements.rb)

elixir/lib/solutions/0238_product_of_array_except_self/product_of_array_except_self.ex

@@ -0,0 +1,24 @@
+defmodule LeetCode.Solutions.ProductOfArrayExceptSelf do
+  @moduledoc false
+
+  @spec call(nums :: [integer]) :: [integer]
+  def call(nums) do
+    # This solution doesn't work because it takes too long
+    # to execute all of the test cases in LeetCode.
+    # See my notes on this problem for more information.
+
+    {prefix_products, _} =
+      Enum.reduce(nums, {[], 1}, fn num, {products, prefix} ->
+        {[prefix | products], prefix * num}
+      end)
+
+    nums
+    |> Enum.reverse()
+    |> Enum.with_index()
+    |> Enum.reduce({prefix_products, 1}, fn {num, index}, {products, suffix} ->
+      {List.update_at(products, index, &(&1 * suffix)), suffix * num}
+    end)
+    |> elem(0)
+    |> Enum.reverse()
+  end
+end

elixir/test/solutions/0238_product_of_array_except_self/product_of_array_except_self_test.exs

@@ -0,0 +1,13 @@
+defmodule LeetCode.Solutions.ProductOfArrayExceptSelfTest do
+  use ExUnit.Case, async: true
+
+  alias LeetCode.Solutions.ProductOfArrayExceptSelf
+
+  test "Case 1 works" do
+    assert [24, 12, 8, 6] == ProductOfArrayExceptSelf.call([1, 2, 3, 4])
+  end
+
+  test "Case 2 works" do
+    assert [0, 0, 9, 0, 0] == ProductOfArrayExceptSelf.call([-1, 1, 0, -3, 3])
+  end
+end

notes/0238_product_of_array_except_self.md

@@ -0,0 +1,61 @@
+# Product of Array Except Self
+
+**Link to Problem**: https://leetcode.com/problems/product-of-array-except-self
+
+## Solutions
+
+- [Elixir](../elixir/lib/solutions/0238_product_of_array_except_self/product_of_array_except_self.ex)
+- [Ruby](../ruby/lib/solutions/0238_product_of_array_except_self/product_of_array_except_self.rb)
+
+## 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]
+```
+
+## Approach
+
+Loop through `nums` from left to right while keeping track of a `prefix` variable.
+
+During the first loop, assign the current value of `prefix` to the output array.
+
+Next, update `prefix` based on the product of the current `prefix` value and the current iteration of `num`.
+
+Next, we do another loop of `nums` from right to left while keeping track of a `suffix` variable.
+
+We update the current iteration of the output array by multiplying it with the current `suffix`.
+
+Next, we update `suffix` based on the product of the current `suffix` value and current iteration of `nums`.
+
+Once the loop is done, we output the resulting array.
+
+## Thoughts
+
+First of all, there was no way I was going to figure out the solution for this problem on my own.
+
+Next, while the algorithm is easy to do in Ruby, doing it in Elixir is impossible without violating
+some of the constraints that the problem has imposed like keeping space complexity to `O(1)`.
+
+Another thing is that my solution for Elixir actually doesn't work. One of the test case for this
+problem has an input that is insanely long that my code in Elixir fails to do this before timing out.
+
+My guess is because I've reversed the list so many times and reversing a list is a very expensive
+operation since lists in Elixir are linked list and not actual arrays.

ruby/.rubocop.yml

@@ -4,3 +4,6 @@ require:
 
 AllCops:
   NewCops: enable
+
+Metrics/MethodLength:
+  Enabled: false

ruby/lib/solutions/0238_product_of_array_except_self/product_of_array_except_self.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+def product_except_self(nums)
+  prefix = 1
+  suffix = 1
+  product = []
+
+  nums.each do |num|
+    product << prefix
+    prefix *= num
+  end
+
+  (nums.length - 1).downto(0) do |index|
+    product[index] *= suffix
+    suffix *= nums[index]
+  end
+
+  product
+end

ruby/test/solutions/0238_product_of_array_except_self/product_of_array_except_self_test.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require_relative '../../../lib/solutions/0238_product_of_array_except_self/product_of_array_except_self'
+
+class ProductOfArrayExceptSelfTest < Minitest::Test
+  def test_case_1_works
+    assert_equal [24, 12, 8, 6], product_except_self([1, 2, 3, 4])
+  end
+
+  def test_case_2_works
+    assert_equal [0, 0, 9, 0, 0], product_except_self([-1, 1, 0, -3, 3])
+  end
+end