FAQ: Technical Interview Problems in Python: Lists - List Rotation: Indices

This community-built FAQ covers the “List Rotation: Indices” exercise from the lesson “Technical Interview Problems in Python: Lists”.

Paths and Courses
This exercise can be found in the following Codecademy content:

Technical Interview Practice: Python

FAQs on the exercise List Rotation: Indices

There are currently no frequently asked questions associated with this exercise – that’s where you come in! You can contribute to this section by offering your own questions, answers, or clarifications on this exercise. Ask or answer a question by clicking reply (reply) below.

If you’ve had an “aha” moment about the concepts, formatting, syntax, or anything else with this exercise, consider sharing those insights! Teaching others and answering their questions is one of the best ways to learn and stay sharp.

Join the Discussion. Help a fellow learner on their journey.

Ask or answer a question about this exercise by clicking reply (reply) below!

Agree with a comment or answer? Like (like) to up-vote the contribution!

Need broader help or resources? Head here.

Looking for motivation to keep learning? Join our wider discussions.

Learn more about how to use this guide.

Found a bug? Report it!

Have a question about your account or billing? Reach out to our customer support team!

None of the above? Find out where to ask other questions here!

The sample code provided for how to modify an input list of strings does not work as described. Namely this block:

def constant_space(list_of_strings):
  # variable the same regardless of input
  exclamation = "!"
  for element in list_of_strings:
    element += exclamation

  # input mutated but no more space used
  return list_of_strings

Running this function does not mutate the original list as described; the output list will be identical to the input list. This is because insertion into a list cannot be done by assigning it to the named variable in a for loop as shown. A way to modify the items in the list in place would be something like this:

def constant_space(list_of_strings):
  excl = '!'
  for i, element in enumerate(list_of_strings):
    list_of_strings[i] = element + excl
  return list_of_strings

This will return and modify the items in the original list by re-assigning a new element at each index. Still O(n) time and O(1) space.

I’m having a hard time understanding why this solution is better than simple insert and pop or swapping every element one by one. Does swapping have worse time or space complexity? It seems good enough for me while the reversing solution is complicated. It’d be better if you could explain the details in the course and why the solution you provided is better than others.


I have the same question.

The execution of the sample code is ~380ms, vs. the execution time of the following .pop() and .insert() approach is 363ms.

def rotate(my_list, num_rotations):
for i in range(num_rotations):
my_list.insert(len(my_list), my_list.pop(0))
return my_list

I think I’m confused about the complexity/efficiency of editing a list with one function vs. two functions. Is it incorrect to conflate execution time with efficiency?

Or, perhaps, is this a context-specific choice to “show your work” in an interview? In this case, we’d be demonstrating we understand the mechanics behind the .pop/.insert “shortcuts” as means by which to display competency?

1 Like

I am not really sure why the Time complexity answer isn’t just continuing to use the slice to modify the current list. My code below still return the same list and also accounts for when the rotations are larger than the list. I have seen some answers that will continue to pop and insert where as my if statement cuts it down to the modulus

def rotate(lst, k):
    if k > len(lst):
        k %= len(lst)
    lst = lst[-k:] + lst[:-k]


I’m not sure how lists are implemented in python, but I’d expect for this to take the same amount of time so long as this is just a linking operations on a noncontiguous data structure

This was my proposal here too, I’d like to undertstand why it wouldn’t work as it still maintains space complexity requirements

I used slicing to do the rotation backward. Isn’t slicing O(1) complexity? or is it linear time O(n)? Nevertheless, going through some posts I still think slicing is the best. Here’s my implementation with slicing:

def rotate(my_list, num_rotations):
rotate_list = list(my_list[num_rotations:] + my_list[:num_rotations])
return rotate_list

My implementation without slicing and using hint:
def rotate(my_list, num_rotations):
my_list = rev(my_list, 0, num_rotations-1)
my_list = rev(my_list, num_rotations, len(my_list)-1)
my_list = rev(my_list, 0, len(my_list)-1)
return my_list

def rev(lst, low, high):
while low < high:
lst[low], lst[high] = lst[high], lst[low]
high -= 1
low += 1
return lst

Isn’t slicing better than the latter?