Python – Product of elements using Index list

Accessing an element from its index is easier task in python, just using the [] operator in a list does the trick. But in certain situations we are presented with tasks when we have more than once indices and we need to get all the elements corresponding to those indices and then perform the multiplication. Lets discuss certain ways to achieve this task. 

Method #1 : Using List comprehension + loop 

This task is easy to perform with a loop, and hence shorthand for it is the first method to start with this task. Iterating over the index list to get the corresponding elements from list into new list is brute method to perform this task. The task of product is performed using loop. 

Original list : [9, 4, 5, 8, 10, 14]
Original index list : [1, 3, 4]
Resultant list : 320

Time Complexity: O(n) where n is the length of the index_list.
Auxiliary Space: O(1) as only a few variables are used and no additional data structure is used.

Method #2 : Using map() + __getitem__ + loop 

Yet another method to achieve this particular task is to map one list with other and get items of indexes and get corresponding matched elements from the search list. This is quite quick way to perform this task. The task of product is performed using loop. 

Original list : [9, 4, 5, 8, 10, 14]
Original index list : [1, 3, 4]
Resultant list : 320

Time Complexity: O(n), where n is the number of elements in the index_list.
Auxiliary Space: O(n), where n is the number of elements in the index_list.

Method #3 : Using reduce() of functools and operator

Original list : [9, 4, 5, 8, 10, 14]
Original index list : [1, 3, 4]
Resultant list : 320

Time complexity: O(n), where n is the number of elements in the index list. 
Auxiliary space: O(m), where m is the number of elements in the index list.

Method 5: Using numpy

Output:

Resultant list : 320

Time complexity: O(n)
Auxiliary Space: O(n)

Method #6: Using a for loop and the math library

Approach:

1. Import the math library using import math.
2. Initialize a variable named product to 1.
3. Loop through each index in the index_list using a for loop.
   • Access the corresponding element in test_list using the current index and multiply it with the product variable.
4. After the loop, print the product variable to get the result.

Below is the implementation of the above approach:

Resultant list : 320

Time complexity: O(n), where n is the length of index_list.
Auxiliary space: O(1), as we only use a constant amount of extra memory to store the product variable.

Method #6: Using a lambda function and reduce()

Approach:

1. Import the reduce() function from functools.
2. Initialize the test_list and index_list as given in the problem statement.
3. Define a lambda function that takes two arguments and returns their product.
4. Use the reduce() function with the lambda function and a list comprehension to calculate the product of the elements of test_list at the indices given in index_list.
5. Assign the product to a variable and print it.

Resultant list : 320

Time complexity: O(n) where n is the length of the index_list.
Auxiliary space: O(m) where m is the length of the index_list, as we are storing a list of m elements extracted from the test_list.

Method #7: Using the itertools library

1. Import necessary modules:
2. reduce function from functools module to perform a specific operation (in this case, multiplication) on all elements of a list.
   itemgetter function from operator module to extract elements from a list using indices.
   combinations function from itertools module to generate all possible combinations of indices.
   Initialize the test_list and index_list variables:
3. test_list is a list of integers.
   index_list is a list of integers representing the indices of elements to be extracted from test_list.
   Define a lambda function prod_lambda that takes a sublist and returns the product of all its elements using the reduce function.
4. Generate all possible combinations of indices using the combinations function and store the result in the index_combinations variable.
5. Extract corresponding elements of test_list for each combination of indices using the itemgetter function and store the result in the sub_lists variable. For each combination, the itemgetter function is called with the indices as argument to extract the corresponding elements from test_list, and the resulting sublist is passed to prod_lambda to compute its product.
6. Take the maximum of the resulting sublists using the max function and store the result in the product variable.
7. Print the maximum product obtained from all the sublists using the print function.

Resultant list : 320

Time complexity: O(n^2), where n is the length of index_list.
Auxiliary space: O(1)