Python | Shift sublist in list
Last Updated :
01 May, 2023
Sometimes, while working with list, we can have a problem in which we need to shift some sublist to the desired index in the same sublist. This problem can occur in day-day programming. Let’s discuss certain ways in which this task can be performed.
Method #1 : Using insert() + pop() + loop
The combination of above functions can be used to perform a particular task. The pop function can be used to remove the sublist and insert function inserts the sublist. This happens for each element in a single iteration in a loop.
Python3
def shift_sublist(test_list, strt_idx, no_ele, shft_idx):
for ele in range (no_ele):
test_list.insert(shft_idx + 1 , test_list.pop(strt_idx))
return test_list
test_list = [ 4 , 5 , 6 , 7 , 3 , 8 , 10 , 1 , 12 , 15 , 16 ]
print ( "The original list is : " + str (test_list))
res = shift_sublist(test_list, 2 , 3 , 6 )
print ( "The list after shift of sublist : " + str (res))
|
Output :
The original list is : [4, 5, 6, 7, 3, 8, 10, 1, 12, 15, 16] The list after shift of sublist : [4, 5, 8, 10, 1, 6, 7, 3, 12, 15, 16]
Time Complexity: O(n*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 new res list
Method #2: Using list slicing
This task can also be done using a list slicing technique in which one can just add the different sections of list at the required positions.
Python3
def shift_sublist(test_list, strt_idx, no_ele, shft_idx):
return (test_list[:strt_idx] + test_list[strt_idx + no_ele : no_ele + shft_idx - 1 ]
+ test_list[strt_idx : strt_idx + no_ele] + test_list[shft_idx + no_ele - 1 :])
test_list = [ 4 , 5 , 6 , 7 , 3 , 8 , 10 , 1 , 12 , 15 , 16 ]
print ( "The original list is : " + str (test_list))
res = shift_sublist(test_list, 2 , 3 , 6 )
print ( "The list after shift of sublist : " + str (res))
|
Output :
The original list is : [4, 5, 6, 7, 3, 8, 10, 1, 12, 15, 16]
The list after shift of sublist : [4, 5, 8, 10, 1, 6, 7, 3, 12, 15, 16]
Time Complexity: O(n) where n is the number of elements in the list “test_list”. Using list slicing performs n number of operations.
Auxiliary Space: O(n), where n is the length of the list.
Method #3: Using list comprehension and slicing
In this method, extract the sublist to be shifted using list slicing, create a new list by iterating through the original list and excluding the indices of the sublist, and insert the shifted sublist at the desired index using slicing.
Python3
def shift_sublist(test_list, strt_idx, no_ele, shft_idx):
shifted_sublist = test_list[strt_idx:strt_idx + no_ele][:: - 1 ]
shifted_list = [test_list[i] for i in range ( len (test_list)) if i not in range (strt_idx, strt_idx + no_ele)]
shifted_list[shft_idx:no_ele + shft_idx] = shifted_sublist
return shifted_list
test_list = [ 4 , 5 , 6 , 7 , 3 , 8 , 10 , 1 , 12 , 15 , 16 ]
print ( "The original list is:" , test_list)
res = shift_sublist(test_list, 2 , 3 , 6 )
print ( "The list after shift of sublist:" , res)
|
Output
The original list is: [4, 5, 6, 7, 3, 8, 10, 1, 12, 15, 16]
The list after shift of sublist: [4, 5, 8, 10, 1, 12, 3, 7, 6]
Time complexity: O(n), where n is the length of the original list. This is because we only need to iterate through the original list once to extract the shifted sublist and create a new list.
Auxiliary space: O(n), as we create a new list to hold the shifted sublist and a new list to hold the remaining elements of the original list.
Method #4: Using reduce():
- Initialize the result as the original list.
- For each shift in the list of shifts:
a. Call shift_sublist function on the result, passing in the current shift.
b. Update the result with the returned value from shift_sublist.
- Return the final result.
Python3
from functools import reduce
def shift_sublist(test_list, strt_idx, no_ele, shft_idx):
return (test_list[:strt_idx] + test_list[strt_idx + no_ele : no_ele + shft_idx - 1 ]
+ test_list[strt_idx : strt_idx + no_ele] + test_list[shft_idx + no_ele - 1 :])
def shift_sublists(test_list, shifts):
return reduce ( lambda res, shift: shift_sublist(res, * shift), shifts, test_list)
test_list = [ 4 , 5 , 6 , 7 , 3 , 8 , 10 , 1 , 12 , 15 , 16 ]
shifts = [( 2 , 3 , 6 ), ( 5 , 2 , 9 ), ( 1 , 4 , 8 )]
result = shift_sublists(test_list, shifts)
print ( "The original list is : " + str (test_list))
print ( "The list after shift of sublists : " + str (result))
|
Output
The original list is : [4, 5, 6, 7, 3, 8, 10, 1, 12, 15, 16]
The list after shift of sublists : [4, 3, 12, 15, 6, 7, 16, 5, 8, 10, 1]
Time complexity: O(n), where n is the length of the input list. The shift_sublists() function applies shift_sublist() function to each tuple in shifts cumulatively using the reduce() function. Therefore, the time complexity of shift_sublists() function is O(mn), where m is the number of tuples in shifts.
Auxiliary space: O(n), where n is the length of the input list. The shift_sublists() function applies shift_sublist() function to each tuple in shifts cumulatively using the reduce() function. Therefore, the space complexity of shift_sublists() function is also O(n).
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...