Python – List product excluding duplicates

This article focuses on one of the operations of getting the unique list from a list that contains a possible duplicated and finding its product. This operation has a large no. of applications and hence its knowledge is good to have.

Method 1: Naive method 

In the naive method, we simply traverse the list and append the first occurrence of the element in new list and ignore all the other occurrences of that particular element. The task of performing the product is done using loop.

The original list is : [1, 3, 5, 6, 3, 5, 6, 1]
Duplication removal list product : 90

Time Complexity: O(n^2)
Auxiliary Space: O(n)

 
Method 2: Using list comprehension 

This method has working similarly to the above method, but this is just a one-liner shorthand for a longer method done with the help of list comprehension. 

The original list is : [1, 3, 5, 6, 3, 5, 6, 1]
Duplication removal list product : 90

Time Complexity: O(n), where n is the number of elements in the list “test_list”.
Auxiliary Space: O(n), where n is the number of elements in the list “test_list”.

Method 3: Using set() and functools.reduce() [Intermediate]

Checking for list membership is O(n) on average, so building up the list of non-duplicates becomes an O(n²) operation on average. One can transform a list into a set to remove the duplicates which is O(n) complexity.  After this the product of the set elements can be calculated in the usual fashion by iterating over them or, to further reduce the code, the reduce() method from functools module can be used. As the documentation explains:

Apply function of two arguments cumulatively to the items of iterable, from left to right, so as to reduce the iterable to a single value.

Here’s how the code can be reduced to a couple of lines

What this does is applies a lambda to the set obtained from the list. The lambda takes in two arguments x, and y and returns the product of the two numbers. This lambda is applied to all the elements in the list cumulatively i.e.

lambda(lambda(lambda(1, 3), 5), 6)….

which yields the final product as 90. It’s always prudent to add in an initial argument to the reduce() function to handle empty sequences so that the default value can be returned. In this case, since it’s a product, that value should be 1. Thus something like

functools.reduce(lambda x,y: x*y, set([]), 1)

yields the output 1, despite the list being empty. This initial argument is added before the values in the sequence and the lambda is applied as usual.

lambda(lambda(lambda(lambda(1,1 ), 3), 5), 6)….

Method 4: Using set() to remove duplicates and for loop to find product

The original list is : [1, 3, 5, 6, 3, 5, 6, 1]
Duplication removal list product : 90

Time complexity : O(n)

Auxiliary Space : O(n), where n is length of test_list.

Method 5: Using math.prod()

The product of distinct elements can be calculated by storing elements in set to remove duplicates, then using math.prod() function to calculate the product.

90

Method 6: Using numpy

Note: Install numpy module using command “pip install numpy”

The numpy library in Python provides a convenient way to perform this operation as well. The numpy library has a prod method that can be used to calculate the product of the elements in an array. To remove duplicates from the list, you can convert the list to a numpy array, use the unique method to get the unique elements, and then calculate the product using the prod method. Here’s an example:

Output:

The original list is : [1, 3, 5, 6, 3, 5, 6, 1]
Duplication removal list product : 90

The time complexity of this approach is O(n) for finding the unique elements using the unique method, and O(m), where m is the number of unique elements, for calculating the product using the prod method. The space complexity is O(m) for storing the unique elements in the numpy array.