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 () 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 () below!
Agree with a comment or answer? Like () to up-vote the contribution!
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.
Hi,
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.
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?
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]
print(lst)
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
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:
) below.
) to up-vote the contribution!