## 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)

a) 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

b) 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

a) 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

b) 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 4th 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

5. (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.)

start

end

For example, the 2×2 grid has a total of two ways for the robot to move from the start to the

goal. For the 3×3 grid, the robot has 6 different paths (only 3 are shown above).

numPaths(2,2) returns 2

numPaths(3,3) returns 6

numPaths(4,5) returns 35

You can start with the following code:

def numPaths(m,n):

#write your code here

def testnumPaths():

#write your code here

6. Iterators

a) iterPrimes()– 10%

Create an iterator that represents the sequence of prime numbers starting at 2.

For example:

>>> primes = iterPrimes()

>>> primes.__next__()

2

>>> primes.__next__()

3

>>> primes.__next__()

5

You can start with the following code:

class iterPrimes():

#write your code here

b) numbersToSum(iNumbers,sum) – 10%

Define a function numbersToSum that takes an iterator “iNumbers” (representing a

sequence of positive integers) and a positive integer value sum, and returns the next n elements

from iNumbers such that the next n elements of the iterator add to less than sum, but the

next (n + 1) elements of the iterator add to sum or more. numbersToSum should return a

list of integers. (Note: Your implementation of numbersToSum doesn’t need to be recursive.

You can’t assume a minimum value for sum. Note that the iterator retrieves the next element in

the sequence in the second call to numbersToSum.)

start

end

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(‘———————‘)