Python | Find elements of a list by indices
Last Updated :
18 Mar, 2023
Given two lists with elements and indices, write a Python program to find elements of list 1 at indices present in list 2.
Examples:
Input : lst1 = [10, 20, 30, 40, 50]
lst2 = [0, 2, 4]
Output : [10, 30, 50]
Explanation:
Output elements at indices 0, 2 and 4 i.e 10, 30 and 50 respectively.
Input : lst1 = ['Hello', 'geeks', 'for', 'geeks']
lst2 = [1, 2, 3]
Output : ['geeks', 'for', 'geeks']
Below are some Pythonic approaches to do the above task.
Approach #1 : Naive(List comprehension) The first approach to find the desired elements is to use list comprehension. We traverse through ‘lst2’ and for each ith element, we output lst1[i].
Python3
def findElements(lst1, lst2):
return [lst1[i] for i in lst2]
lst1 = [10, 20, 30, 40, 50]
lst2 = [0, 2, 4]
print(findElements(lst1, lst2))
|
Time complexity: O(n), where n is the length of lst2
Auxiliary space: O(m), where m is the length of the returned list.
Approach #2 : Using Python map() We can also use Python map() method where we apply lst1.__getitem__ function on lst2 which return lst1[i] for each element ‘i’ of lst2.
Python3
def findElements(lst1, lst2):
return list(map(lst1.__getitem__, lst2))
lst1 = [10, 20, 30, 40, 50]
lst2 = [0, 2, 4]
print(findElements(lst1, lst2))
|
Time complexity: O(n), where n is the length of lst2.
Auxiliary space: O(m), where m is the length of lst2.
Approach #3 : Using itemgetter()
Python3
from operator import itemgetter
def findElements(lst1, lst2):
return list((itemgetter(*lst2)(lst1)))
lst1 = [10, 20, 30, 40, 50]
lst2 = [0, 2, 4]
print(findElements(lst1, lst2))
|
Time complexity: O(m), where m is the length of the lst2 list.
Auxiliary space: O(m+k), where k is the length of the returned list.
Approach #4: Using numpy
Python3
import numpy as np
def findElements(lst1, lst2):
return list(np.array(lst1)[lst2])
lst1 = [10, 20, 30, 40, 50]
lst2 = [0, 2, 4]
print(findElements(lst1, lst2))
|
The time complexity of this program is O(n), where n is the length of lst2.
The space complexity of this program is O(n), where n is the length of lst2.
Approach #6: Using a dictionary
This approach involves creating a dictionary that maps the indices in lst2 to their corresponding elements in lst1. Then, we can uselist comprehension to extract the values from the dictionary.
In this code, we first create a dictionary called index_map that maps the indices of lst1 to their corresponding elements. Then, we use a list comprehension to extract the values from index_map for the indices in lst2. Finally, we return the list of extracted values as the result.
Python3
def findElements(lst1, lst2):
index_map = {index: element for index, element in enumerate(lst1)}
return [index_map[index] for index in lst2]
lst1 = [10, 20, 30, 40, 50]
lst2 = [0, 2, 4]
print(findElements(lst1, lst2))
|
Time complexity: O(n)
Auxiliary space: O(n)
Method#7: Using Recursive method.
Algorithm:
- Define a function findElements that takes in two lists lst1 and lst2, and an index idx (optional, default=0) and a list res (optional, default=[]).
- If idx is equal to the length of lst2, return res (base case).
- Get the element at the index lst2[idx] in lst1 and append it to res.
- Recursively call findElements with the updated idx (idx+1) and res.
- Return the final value of res after all recursive calls have finished.
Python3
def findElements(lst1, lst2, idx=0, res=[]):
if idx == len(lst2):
return res
res.append(lst1[lst2[idx]])
return findElements(lst1, lst2, idx+1, res)
lst1 = [10, 20, 30, 40, 50]
lst2 = [0, 2, 4]
res = findElements(lst1, lst2)
print(res)
|
Time Complexity: O(n), where n is the length of lst2. We visit each element of lst2 exactly once, and the time taken to get the element at each index in lst1 is constant time. So the time complexity is proportional to the length of the input list lst2.
Auxiliary Space: O(n), where n is the length of lst2. This is because we need to store the list of elements in res, which can have a maximum length of n if all indices in lst2 are valid. Additionally, the recursive calls use up memory on the call stack, which can go up to a depth of n if all indices in lst2 are valid.
Please Login to comment...