Due: Thursday, February 20 at 11:59 pm
Submission: On Courseworks
Please read the instructions carefully. An incorrectly formatted submission may not be counted.
There is one question in this assignment.
This assignment starts from skeleton code called lists.py.
Fill in your answers without modifying the tester code.
Please include comments in your code detailing your thought process where appropriate.
Put lists.py in a folder called uni-hw3 (so for me this would be tkp2108-hw3).
Then compress this folder into a .zip file.
For most operating systems, you should be able to right click and have a “compress” option in the context menu.
This should create a file called tkp2108-hw3.zip (with your uni).
Submit this on courseworks.
Note: You can consider the example outputs the result of a “minimum viable solution”. There are many different ways to accomplish the same functionality, and you should feel free to add any additional functionality or get creative so long as this functionality remains. As always, please feel free to ask clarifying questions.
Lists are one of the most important types in Python. In this problem, you have 7 list-oriented problems to solve. Descriptions are given in the skeleton code.
The bottom of the assignment contains a large number of test cases. These can be used as examples to help understand what each function should do. Feel free to comment them out as you work, but be careful making modifications as we will use these same test cases when we grade. If you make modifications, your code might no longer work with our testers.
lists.py
def lists_a(inputs):
'''Replace all even elements in `inputs` by 0'''
# YOUR CODE HERE
def lists_b(lst):
'''Shift all elements by one to the right and move the last element into the first position'''
# YOUR CODE HERE
def lists_c(inputs):
'''Remove the middle element if the list length is odd, or the middle two elements if the length is even.'''
# YOUR CODE HERE
def lists_d(inputs):
'''Replace each element except the first and last by the larger of its two neighbors'''
# YOUR CODE HERE
def lists_e(lst):
'''Return 1 if the list contains two adjacent duplicate elements, else -1'''
# YOUR CODE HERE
def lists_f(inputs):
'''Return a list containing the count of each input in `inputs`'''
# YOUR CODE HERE
def lists_g(inputs):
'''Given a string input `inputs`, return 4 lists:
- all of the lower case letters in `inputs`
- all of the upper case letters in `inputs`
- all of the digits in `inputs`
- all of the special characters in `inputs`
'''
# YOUR CODE HERE
##############
# Test Cases #
##############
# lists_a
assert lists_a([]) == []
assert lists_a([1, 2]) == [1, 0]
assert lists_a([1, 2, 3, 4, 5]) == [1, 0, 3, 0, 5]
assert lists_a(list(range(1, 10, 2))) == [1, 3, 5, 7, 9]
assert lists_a(list(range(0, 10, 2))) == [0, 0, 0, 0, 0]
# lists_b
assert lists_b([]) == []
assert lists_b([1, 2]) == [2, 1]
assert lists_b([1, 2, 3, 4, 5]) == [5, 1, 2, 3, 4]
assert lists_b(list(range(1, 10, 2))) == [9, 1, 3, 5, 7]
assert lists_b(list(range(0, 10, 2))) == [8, 0, 2, 4, 6]
# lists_c
assert lists_c([]) == []
assert lists_c([1, 2]) == []
assert lists_c([1, 2, 3, 4, 5]) == [1, 2, 4, 5]
assert lists_c([1, 2, 3, 4]) == [1, 4]
# lists_d
assert lists_d([]) == []
assert lists_d([1, 2]) == [1, 2]
assert lists_d([1, 2, 1]) == [1, 1, 1]
assert lists_d([1, 2, 3, 4, 5]) == [1, 3, 4, 5, 5]
# lists_e
assert lists_e([]) == -1
assert lists_e([1, 2]) == -1
assert lists_e([1, 2, 1]) == -1
assert lists_e([1, 1, 1]) == 1
assert lists_e([1, 2, 2]) == 1
assert lists_e([2, 2, 1]) == 1
# lists_f
assert lists_f([]) == []
assert lists_f([1, 2]) == [1, 1]
assert lists_f([1, 2, 1]) == [2, 1, 2]
assert lists_f([1, 1, 1]) == [3, 3, 3]
assert lists_f([1, 2, 2]) == [1, 2, 2]
# lists_g
assert lists_g("") == ([], [], [], [])
assert lists_g("a") == (["a"], [], [], [])
assert lists_g("A") == ([], ["A"], [], [])
assert lists_g("1") == ([], [], ["1"], [])
assert lists_g("!") == ([], [], [], ["!"])
assert lists_g("aA1!") == (["a"], ["A"], ["1"], ["!"])
assert lists_g("aA1!aA1!") == (["a"], ["A"], ["1"], ["!"])
assert lists_g("1Ab!aB.2") == (["b", "a"], ["A", "B"], ["1", "2"], ["!", "."])