Python | Variable list slicing

The problem of slicing a list has been dealt earlier, but sometimes we need to perform the slicing in variable lengths according to the input given in other list. This problem has its potential application in web development. Let’s discuss certain ways in which this can be done. 

Method #1 : Using itertools.islice() + list comprehension The list comprehension can be used to iterate through the list and the component issue is solved using the islice function. 

The original list : [1, 5, 3, 7, 8, 10, 11, 16, 9, 12]
The slice list : [2, 1, 3, 4]
The variable sliced list is : [[1, 5], [3], [7, 8, 10], [11, 16, 9, 12]]

Time complexity: O(n), where n is the length of test_list.
Auxiliary space: O(n), where n is the length of res list for storing the result.

  Method #2 : Using zip() + accumulate() + list slicing Apart from using the list comprehension to perform the task of binding, this method uses zip function to hold sublist element together, accumulate function joins the elements, and slicing is used to construct the required slicing. 

The original list : [1, 5, 3, 7, 8, 10, 11, 16, 9, 12]
The slice list : [2, 1, 3, 4]
The variable sliced list is : [[1, 5], [3], [7, 8, 10], [11, 16, 9, 12]]

 Method #3 : Using looping and slicing

This approach iterates over the slice list and uses slicing to extract the corresponding sublists from the original list. The starting and ending indices for the slices are calculated using the current value in the slice list and the previous ending index. This solution has a time complexity of O(n), where n is the length of the slice list, and a space complexity of O(n), because it creates a new list to store the result.

The original list : [1, 5, 3, 7, 8, 10, 11, 16, 9, 12]
The slice list : [2, 1, 3, 4]
[[1, 5], [3], [7, 8, 10], [11, 16, 9, 12]]

Method #4 : Using list comprehension and zip() function

The idea is to use the zip() function to pair the slice_list with the starting index, and then use list comprehension to slice the test_list based on the paired values.

Step-by-step approach:

• Uses a list comprehension and the zip() function to create a new list. The list comprehension iterates over the test_list using i as the starting index and j as the length of the slice.
• In the zip() function, two arguments are passed. The first argument is a list created using list concatenation with [0] and the accumulated values of the slice_list. The accumulate function generates the accumulated sum of the slice_list. The second argument passed to zip() is the slice_list itself.
• The resulting list is stored in the variable named result.
• The result is printed.

Below is the implementation of the above approach:

[[1, 5], [3], [7, 8, 10], [11, 16, 9, 12]]

Time complexity: O(n), where n is the length of test_list.
Auxiliary space: O(n), where n is the length of test_list (for storing the result list).

Method 5: Using numpy.split()

You can also solve the problem using the numpy.split() function. This method requires the installation of the NumPy library. 

1. First, we import the NumPy library using the line import numpy as np.
2. We initialize a test list test_list with some integer values: [1, 5, 3, 7, 8, 10, 11, 16, 9, 12].
3. We also initialize a slice list slice_list with some integer values: [2, 1, 3, 4]. This will be used to define the lengths of the slices of test_list.
4. We use the numpy.cumsum() function to compute the cumulative sum of the slice_list with a 0 added at the beginning of the list, which is done by [0] + slice_list. This gives us a new list starts which has the starting positions of each slice in the test_list.
5. We use a list comprehension to extract the corresponding slice from the test_list using the starting positions computed in the previous step. The slice for each starting position is computed as test_list[starts[i]:starts[i+1]], where i is the index of the starting position. The result is a list of lists, where each sublist is a slice of test_list.
6. Finally, we print the resulting list of lists, which is stored in the result variable.

OUTPUT:

[[1, 5], [3], [7, 8, 10], [11, 16, 9, 12]]

The time complexity of this method is O(n), where n is the length of the test_list. 

Auxiliary space usage can be O(n+m), where n is the length of the test_list and m is the length of the slice_list.