Python | Get elements till particular element in list

Sometimes, while working with Python list, we can have a requirement in which we need to remove all the elements after a particular element, or, get all elements before a particular element. These both are similar problems and having a solution to it is always helpful. Let’s discuss certain ways in which this task can be performed. 

Method #1 : Using index() + list slicing This problem can be solved using the combination of these functions. The index() can be used to find the index of desired element and list slicing can perform the remaining task of getting the elements. 

The original list is : [1, 4, 6, 8, 9, 10, 7]
Elements till N in list are : [1, 4, 6]

The time complexity of the given code is O(n), where n is the length of the input list.

The auxiliary space complexity of the code is O(n), as a new list is created with the elements up to the index of N using list slicing.

  Method #2 : Using generator This task can also be performed using the generator function which uses yield to get the elements just till the required element and breaks the yields after that element. 

The original list is : [1, 4, 6, 8, 9, 10, 7]
Elements till N in list are : [1, 4, 6]

Time Complexity: O(n), where n is the length of the list test_list 
Auxiliary Space: O(n) additional space of size n is created where n is the number of elements in the res list 

Method #3 : Using list.takewhile()
This method can be used to get the elements till a certain element in the list, it takes a function as an argument and stop taking elements when that function returns false.

The original list is : [1, 4, 6, 8, 9, 10, 7]
Elements till N in list are : [1, 4, 6]

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

Method#4: Using Recursive method.

• Define a function named get_elements_till which takes a list lst and an integer n as arguments.
• Check if the list is empty. If it is, return an empty list.
• Check if the first element of the list is equal to n. If it is, return an empty list.
• If the above conditions are not satisfied, return a list containing the first element of the list followed by the result of calling the function recursively on the remaining elements of the list.
• Initialize the input list and the integer N.
• Call the get_elements_till function with the input list and integer N as arguments.
• Print the result.

The original list is : [1, 4, 6, 8, 9, 10, 7]
Elements till N in list are : [1, 4, 6]

Time complexity: O(n), where n is the length of the input list.
Auxiliary Space: O(n), where n is the length of the input list, due to the recursive calls made to the function.

Method#5: Using enumeration

Here’s the step-by-step algorithm for getting elements till a particular element in a list using index() and list slicing with enumeration:

• Initialize the original list test_list.
• Declare the particular element N till which the elements are required.
• Loop over the elements in test_list along with their index using enumerate().
  • In each iteration, check if the current element is equal to N.
  • If the current element is equal to N, save its index in a variable index_N and break out of the loop.
  • Use index_N to slice the list and get the elements before N.
• Print the original list and the elements before N.

The original list is : [1, 4, 6, 8, 9, 10, 7]
Elements till N in list are : [1, 4, 6]

Time complexity: O(n)

1. Finding the index of the first occurrence of N in test_list takes O(n) time in the worst case, where n is the length of test_list.
2. Slicing the list using index_N takes O(index_N) time.
3. Therefore, the time complexity of the algorithm is O(n) in the worst case.  

Auxiliary Space: O(1)

The algorithm uses a constant amount of extra space, so the space complexity is O(1).

Method#6: Using numpy.where(): 

Algorithm:

1.Convert the list to a numpy array
2.Find the index of the element N using np.where() function
3.Slice the list from the beginning to the index of N

Output:

The original list is : [1, 4, 6, 8, 9, 10, 7]
Elements till N in list are : [1, 4, 6]

Time complexity: O(n)

Converting the list to a numpy array takes O(n) time
Finding the index of N using np.where() takes O(1) time on average
Slicing the list takes O(n) time in the worst case (when N is the last element of the list)
Space complexity: O(n)

Converting the list to a numpy array requires creating a new array with the same elements, thus taking O(n) space.