CptS-Assignment 3 (Python);Solution

Description

Problems:

1. Dictionaries – busStops(b) – 15%

Pullman Transit offers many bus routes in Pullman. Assume that they maintain the bus stops for their routes as a dictionary. The keys in the dictionary are the bus routes and the values are the stops for the bus routes (see below for an example).

buses = {

“Lentil”: [“Chinook”, “Orchard”, “Valley”, “Emerald”,”Providence”, “Stadium”, “Main”, “Arbor”, “Sunnyside”, “Fountain”, “Crestview”, “Wheatland”, “Walmart”, “Bishop”, “Derby”, “Dilke”],

“Wheat”: [“Chinook”, “Orchard”, “Valley”, “Maple”,”Aspen”, “TerreView”, “Clay”, “Dismores”, “Martin”, “Bishop”, “Walmart”, “PorchLight”, “Campus”],

“Silver”: [“TransferStation”, “PorchLight”, “Stadium”, “Bishop”,”Walmart”, “Shopco”, “RockeyWay”],

“Blue”: [“TransferStation”, “State”, “Larry”, “TerreView”,”Grand”, “TacoBell”, “Chinook”, “Library”],

“Gray”: [“TransferStation”, “Wawawai”, “Main”, “Sunnyside”,”Crestview”, “CityHall”, “Stadium”, “Colorado”]

}

Write a function busStops that takes a dictionary mapping bus routes to bus stops (as shown above) and returns another dictionary mapping bus stops to list of bus routes which stop at that stop. The route list for each stop should be alphabetically sorted. For example:

busStops(buses) returns

{‘Chinook’: [‘Blue’, ‘Lentil’, ‘Wheat’], ‘Orchard’: [‘Lentil’,

‘Wheat’], ‘Valley’: [‘Lentil’, ‘Wheat’], ‘Emerald’: [‘Lentil’],

‘Providence’: [‘Lentil’], ‘Stadium’: [‘Gray’, ‘Lentil’, ‘Silver’],

‘Main’: [‘Gray’, ‘Lentil’], ‘Arbor’: [‘Lentil’], ‘Sunnyside’: [‘Gray’,

‘Lentil’], ‘Fountain’: [‘Lentil’], ‘Crestview’: [‘Gray’, ‘Lentil’],

‘Wheatland’: [‘Lentil’], ‘Walmart’: [‘Lentil’, ‘Silver’, ‘Wheat’],

‘Bishop’: [‘Lentil’, ‘Silver’, ‘Wheat’], ‘Derby’: [‘Lentil’], ‘Dilke’:

[‘Lentil’], ‘Maple’: [‘Wheat’], ‘Aspen’: [‘Wheat’], ‘TerreView’:

[‘Blue’, ‘Wheat’], ‘Clay’: [‘Wheat’], ‘Dismores’: [‘Wheat’], ‘Martin’:

[‘Wheat’], ‘PorchLight’: [‘Silver’, ‘Wheat’], ‘Campus’: [‘Wheat’],

‘TransferStation’: [‘Blue’, ‘Gray’, ‘Silver’], ‘Shopco’: [‘Silver’],

‘RockeyWay’: [‘Silver’], ‘State’: [‘Blue’], ‘Larry’: [‘Blue’], ‘Grand’:

[‘Blue’], ‘TacoBell’: [‘Blue’], ‘Library’: [‘Blue’], ‘Wawawai’:

[‘Gray’], ‘CityHall’: [‘Gray’], ‘Colorado’: [‘Gray’]}

You should not hardcode route names and the bus stop names in your function. You can start with the following code:

def busStops(b):

#write your code here

def testbusStops():

#write your code here

2. (Dictionaries)

   1. addDict(d) – 10%

Assume you keep track of the number of hours you study every day for each of the courses you are enrolled in. You maintain the weekly log of your hours in a Python dictionary as follows:

{‘Mon’:{‘355′:2,’451′:1,’360′:2},’Tue’:{‘451′:2,’360’:3}, ‘Thu’:{‘355′:3,’451′:2,’360’:3}, ‘Fri’:{‘355’:2}, ‘Sun’:{‘355′:1,’451′:3,’360’:1}}

The keys of the dictionary are the days you studied and the values are the dictionaries which include the number of hours for each of the courses you studied. Please note that you may not study for some courses on some days OR you may not study at all on some days of the week.

Define a function, addDict(d) which adds up the number of hours you studied for each of the courses during the week and returns the summed values as a dictionary. Note that the keys in the resulting dictionary should be the course names and the values should be the total number of hours you have studied for the corresponding courses. addDict would return the following for the above dictionary: {‘355’: 8, ‘451’: 8, ‘360’: 9}

(Important note: Your function should not hardcode the course numbers and days of the week. It should simply iterate over the keys that appear in the given dictionary and should work on any dictionary with arbitrary course numbers and days of the week)

(Important note: When we say a function returns a value, it doesn’t mean that it prints the value. Please pay attention to the difference.)

Define a function testaddDict() that tests your addDict(d) function, returning True if the code passes your tests, and False if the tests fail. You can start with the following code:

def addDict(d):

#write your code here

def testaddDict():

#write your code here

2. addDictN(L) – 10%

Now assume that you kept the log of number of hours you studied for each week on each class throughout the semester and stored that data as a list of dictionaries. This list includes a dictionary for each week you recorded your log. Assuming you kept the log for N weeks, your list will include N dictionaries.

Define a function addDictN which takes a list of weekly log dictionaries and returns a dictionary which includes the total number of hours that you have studied for your enrolled courses throughout the semester. Your function definition should use the Python map and reduce functions as well as the addDict function you defined in part(a). You may need to define an additional helper function.

Example:

Assume you have recorded your log for 3 weeks only.

[{‘Mon’:{‘355′:2,’360′:2},’Tue’:{‘451′:2,’360′:3},’Thu’:{‘360’:3}, ‘Fri’:{‘355’:2}, ‘Sun’:{‘355’:1}}, {‘Tue’:{‘360′:2},’Wed’:{‘355′:2},’Fri’:{‘360’:3, ‘355’:1}}, {‘Mon’:{‘360′:5},’Wed’:{‘451′:4},’Thu’:{‘355′:3},’Fri’:{‘360’:6}, ‘Sun’:{‘355’:5}}]

For the above dictionary addDictN will return:

{‘355’: 16, ‘360’: 24, ‘451’: 6}

(The items in the dictionary can have arbitrary order.)

You can start with the following code:

def addDictN(L):

#write your code here

def testaddDictN():

#write your code here

3. Dictionaries and lists

1. searchDicts(L,k)– 5%

Write a function searchDicts that takes a list of dictionaries L and a key k as input and checks each dictionary in L starting from the end of the list. If k appears in a dictionary, searchDicts returns the value for key k. If k appears in more than one dictionary, it will return the one that it finds first (closer to the end of the list).

For example:

L1 = [{“x”:1,”y”:True,”z”:”found”},{“x”:2},{“y”:False}]

searchDicts(L1,”x”) returns 2 searchDicts(L1,”y”) returns False searchDicts(L1,”z”) returns “found” searchDicts(L1,”t”) returns None

You can start with the following code: def searchDicts(L,k):

#write your code here

def testsearchDicts(): #write your code here

2. searchDicts2(tL,k) – 10%

Write a function searchDicts2 that takes a list of tuples (tL) and a key k as input. Each

tuple in the input list includes an integer index value and a dictionary. The index in each tuple represent a link to another tuple in the list (e.g. index 3 refers to the 4^th tuple, i.e., the tuple at index 3 in the list) searchDicts2 checks the dictionary in each tuple in tL starting from the end of the list and following the indexes specified in the tuples.

For example, assume the following:

[(0,d0),(0,d1),(0,d2),(1,d3),(2,d4),(3,d5),(5,d6)]

0 1 2 3 4 5 6

The searchDicts2 function will check the dictionaries d6,d5,d3,d1,d0 in order (it will skip over d4 and d2) The tuple in the beginning of the list will always have index 0.

It will return the first value found for key k. If k is couldn’t be found in any dictionary, then it will return None.

For example:

L2 = [(0,{“x”:0,”y”:True,”z”:”zero”}),

(0,{“x”:1}),

(1,{“y”:False}),

(1,{“x”:3, “z”:”three”}),

(2,{})]

searchDicts2 (L2,”x”) returns 1

searchDicts2 (L2,”y”) returns False

searchDicts2 (L2,”z”) returns “zero”

searchDicts2 (L2,”t”) returns None

(Note: I suggest you to provide a recursive solution to this problem.

Hint: Define a helper function with an additional parameter that hold the list index which will be

searched in the next recursive call.)

You can start with the following code:

def searchDicts2(L,k):

#write your code here

def testsearchDicts2():

#write your code here

4. (Lists) subsets – 20%

Write a function subsets , which takes a list, L, as input and returns a list of lists, each of the sublists being one of the 2^length(L) subsets of L. The subsets should appear in increasing length. You may assume that all of the elements of the original list are distinct.

(Hint: Try solving this using recursion and map function.)

For example: subsets ([1,2,3])

returns [[],[1],[2],[3],[1,2],[1,3],[2,3],[1,2,3]]

subsets([(1,”one”),(2,”two”)])

returns [[],[(1,”one”)],[(2,”two”)],[(1,”one”),(2,”two”)]]

subsets([]) returns [[]]

You can start with the following code: def subsets(L):

#write your code here

def testsubsets():

#write your code here

4. (Recursion) numPaths(m,n) – 10%

Consider a robot in a MxN grid who is only capable of moving right or down in the grid. The robot starts at the top left corner, (0,0), and is supposed to reach to the bottom right corner, (M-1,N-1). Write a function numPaths that takes the grid length and width (i.e., M, N) as argument and returns the number of different paths the robot can take from the start to the

goal. Give and answer using recursion. (A correct solution without recursion will worth half the points.)

For example:

• primes = iterPrimes()

• numbersToSum(primes,58) [2, 3, 5, 7, 11, 13]

• numbersToSum(primes,100) [17, 19, 23, 29]

You can start with the following code:

def numbersToSum(iNumbers,sum):

#write your code here

def testnumbersToSum():

#write your code here; see the sample test function below

Test your code:

Here is an example test function for testing numbersToSum. Make sure to include 2 test cases for each function.

• function to test numbersToSum

• return True if successful, False if any test fails def testnumbersToSum():

primes = iterPrimes()

if numbersToSum(primes, 58) != [2, 3, 5, 7, 11, 13]: return False

if numbersToSum(primes, 100) != [17, 19, 23, 29]: return False

return True

You don’t need to provide a test function for 6(a) – iterPrimes. You should write test functions for all other problems.

Go on writing test code for ALL of your code here; think about edge cases, and other points where you are likely to make a mistake.

Main Program

So far we’ve just defined a bunch of functions in our HW3.py program. To actually execute the code, we need to write the code for the “main” program. Unlike in C or Java, this is not done by writing a function with a special name. Instead the following idiom is used. This code is to be written at the left margin of your input file (or at the same level as the def lines if you’ve indented those.

if __name__ == ‘__main__’:

…code to do whatever you want done…

For this assignment, we want to run all the tests, so your main should look like:

testFunctions = {“busStops”:testbusStops, “addDict”: testaddDict,

“addDictN”: testaddDictN, “searchDicts”: testsearchDicts, “searchDicts2”:

testsearchDicts2, “subsets”:testsubsets, “numPaths”: testnumPaths, “numbersToSum”:testnumbersToSum }

if __name__ == ‘__main__’:

for testName,testFunc in testFunctions.items():

print(testName,‘: ‘,testFunc())

print(‘———————‘)