Supplemental notebook contains:

• Function to check if a list contains a certain element. I used binary search.

• String pre-processing and duplicate removal.
• Even Fibonacci sum.
• # unique letters and numbers in a list.
• Function to flatten a heavily nested list.
• Function to count consecutive pairs.
• Anagrams from common words list.
• Pre-processing with regex and count the occurrence of unique letters.
• Function that inverts a dictionary.
• Function that calculates airplane route from list of tuples.
• Function that takes an integer and returns elements in reverse order.
• Tic-tac-toe game: establish a winner based on the contents of the matrix. I used
transpose for columns and sets.
Problem 0
Fast searching in ordered collections. This problem consists of just a single exercise, worth ten (10) points. It is about an elementary principle
science algorithm design, which is that one can often do things faster if one exploits structure in the input data.

Suppose you are given a list of already sorted numbers.

In [ ]: A = [2, 16, 26, 32, 52, 71, 80, 88]

# These are already sorted:

assert A == sorted(A)

Suppose you now want to know whether a certain value exists in this list. A simple way to do that in Python is as follows.

In [ ]: def contains(A, x):

"""Returns True only if the value `x` exists in `A`."""
return x in A

print("A contains 32: {}".format(contains(A, 32)))

print("A contains 7: {}".format(contains(A, 7)))
print("A contains -10: {}".format(contains(A, -10)))

This method works fine and is reasonably fast on small lists. However, if the list is very large, this method can be wasteful, computationally spe

That's because it does not take advantage of the fact that A is already ordered. In such a case, it should be easier to determine whether the ele
(How?)

Exercise 0 (3 + 7 == 10 points). Write a function, ordered_contains(S, x), that takes an already sorted list, S, as input, and determines w
contains x. But there is one more condition: your method must be at least ten times faster than contains() for "large" lists!

In particular, there are two test codes for this exercise. The first one checks that your procedure does, indeed, return the correct result by comp
output to contains(), which we will assume is correct. Correctness is worth three (3) points of partial credit out of ten (10). The second test c
whether your implementation is faster than contains() for a relatively large, but ordered, list. If your implementation is slower for smaller lists

Hint. If you can find a standard Python library routine to help you, by all means, use it!

In [ ]: def ordered_contains(S, x):

# You may assume that `S` is sorted
### BEGIN SOLUTION
return ordered_contains__2(S, x)

# Version 0: Use Python's built-in `bisect()` routine

def ordered_contains__0(S, x):
from bisect import bisect
i = bisect(S, x)
return i > 0 and S[i-1] == x

# Version 1: A manual implementation of binary search.

#
# This is the algorithm that this exercise is intended to
# "introduce."

Try
# https://en.wikipedia.org/wiki/Binary_search_algorithm
#
# However, for a variety of implementation reasons, this
solution of
# implementation is unlikely to beat Version 0, above.
# Any ideas why not? the binary
#
THRESHOLD__1 = 128 # An "engineering" constant - use to tune speed
def ordered_contains__1(S, x):
search
if len(S) <= THRESHOLD__1:
return contains(S, x)
midpoint = int(len(S) / 2)
if x < S[midpoint]:
return ordered_contains__1(S[:midpoint], x)
if x > S[midpoint]:
return ordered_contains__1(S[midpoint+1:], x)
return True # Found it!

# The following method improves on the above. Why is it faster?

THRESHOLD__2 = 8 # An "engineering" constant - use to tune speed
i
 def ordered_contains__2(S, x, l=0, r=None):
if r is None: r = len(S)
if (r-l) <= THRESHOLD__2:
return contains(S[l:r], x)
midpoint = int((l+r) / 2)
if x < S[midpoint]:
return ordered_contains__2(S, x, l, midpoint)
if x > S[midpoint]:
return ordered_contains__2(S, x, midpoint+1, r)
return True # Found it!
### END SOLUTION

print("A contains 32: {}".format(ordered_contains(A, 32)))

print("A contains 7: {}".format(ordered_contains(A, 7)))
print("A contains -10: {}".format(ordered_contains(A, -10)))
print("\n(Did those results match the earlier example?)")

In [ ]: # Test cell: `test_is_correct` (1 point)

from random import randint, sample

def gen_list(n, v_max, v_min=0):

return sample(range(v_min, v_max), n)

def gen_sorted_list(n, v_max, v_min=0):

return sorted(gen_list(n, v_max, v_min))

def check_case(S, x):

msg = "`contains(S, {}) == {}` while `ordered_contains(S, {}) == {}`!"
true_solution = contains(S, x)
your_solution = ordered_contains(S, x)
assert your_solution == true_solution, msg.format(true_solution, your_solution)

S = gen_sorted_list(13, 100)
print("Checking your code on this input: S = {}".format(S))

check_case(S, S[0])
check_case(S, S[0]-1)
check_case(S, S[-1])
check_case(S, S[-1]+1)

for x in gen_list(50, 100, -100):

check_case(S, x)
print("\n(Passed basic correctness checks.)")

print("\nTiming `contains()`...")
x = randint(-100, 100)
%timeit contains(S, x)

print("\nTiming `ordered_contains()`...")
%timeit ordered_contains(S, x)

print("\n(This problem is small, so it's okay if your method is slower.)")

print("\n(Passed!)")

In [ ]: # Test cell: `test_is_faster` (7 points)

N_MIN = 1000000
N_MAX = 2*N_MIN
R_MAX = max(10*N_MAX, 1000000000)

n = randint(N_MIN, N_MAX)
print("Generating a list of size n={}...".format(n))

S_large = gen_sorted_list(n, R_MAX)

print("Quick correctness check...")

x = randint(-R_MAX, R_MAX)
check_case(S_large, x)
print("\n(Passed.)")

print("\nTiming `contains()`...")
t_baseline = %timeit -o contains(S_large, x)
print("\nTiming `ordered_contains()`...")
t_better = %timeit -o ordered_contains(S_large, x)

speedup = t_baseline.average / t_better.average

assert speedup >= 10, "Your method was only {:.2f}x faster (< 1 means it was slower)!".format(sp

print("\n(Passed -- you were {:.1f}x faster!)".format(speedup))

Fin! You've reached the end of this problem. Don't forget to restart the kernel and run the entire notebook from top-to-bottom to make sure you
everything correctly. If that is working, try submitting this problem. (Recall that you must submit and pass the autograder to get credit for your w
Problem 1
This problem has 2 exercises, worth a total of 10 points.

Exercise 0 (2 points). Write a function, transform that takes a string and performs the following operations to it: converts the string to lower c
only and removes any spaces in the string.

In this problem, "space" means only the space character, not other forms of whitespace, such as tabs and newlines.

For example:

assert transform('Hello, World!') == 'hello,world'

In [ ]: def transform(k):
### BEGIN SOLUTION
return (k.lower().replace(" ", ""))
###END SOLUTION

print(transform('Hello, World!'))

In [ ]: # Test cell: test_transform

assert transform('HELLO').isupper() is False

assert transform(' ').isspace() is False
assert transform('HeL lO\ttHe\nRe') == 'hello\tthe\nre'

print("\n(Passed!)")

Exercise 1 (3 + 5 == 8 points). Write a function, remove_dups(S) that takes a list S and removes multiple occurrences of any element. The fu
a list with only one occurrence of each element.

For example, remove_dups(['cat', 'dog', 'sheep', 'dog']) would return ['cat', 'dog', 'sheep'].

This exercise has two test cells. The first checks that your implementation returns the right answer. The second tests your solution on a large lis
credit, your implementation must take less than a certain amount of time!

In [ ]: def remove_dups(S):
###BEGIN SOLUTION
return remove_dups_1(S)

def remove_dups_0(S): # Correct, but relatively slow on large lists

newList = []
for i in S:
if i not in newList:
newList.append(i)
return newList

def remove_dups_1(S): # Should be much faster

return list(set(S))
###END SOLUTION

In [ ]: # Test cell: test_remove_dups_correct

listA = ['cat', 'dog', 'sheep', 'dog']
listB = [1,2,3,4,3,2,1,5]

assert isinstance(remove_dups(listA), list)

your_listA = remove_dups(listA)
assert len(remove_dups(listA)) == 3 and set(your_listA) == {'cat', 'dog', 'sheep'}
your_listB = remove_dups(listB)
assert len(remove_dups(listB)) == 5 and set(your_listB) == set(range(1,6))

print("\n(Passed!)")

In [ ]: # Test cell: test_remove_dups_fast

from random import sample

large_list = sample(range(1000000000), 10000)
i i i i i
 timing = %timeit -o remove_dups(large_list)
assert timing.average < 1e-2 # 10 ms time limit for 10,000 elements

Fin! You've reached the end of this problem. Don't forget to restart the kernel and run the entire notebook from top-to-bottom to make sure you
everything correctly. If that is working, try submitting this problem. (Recall that you must submit and pass the autograder to get credit for your w

Problem 2: Even Fibonacci Terms

This problem consists of just a single exercise, worth ten (10) points. This problem is the second of many on the site Project Euler
(http://www.projecteuler.net), a set of Number Theory-based computational problems. You might find some of the other problems to be
challenges - but be warned, they scale up in difficulty quickly as you complete them!

Each new term in the Fibonacci sequence is generated by adding the previous two terms. By starting with 1 and 1, the list of terms not exceed

1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89.

That is, the next term, 55+89=144, exceeds 100, so we would stop at 89.

Your computational task is to calculate the sum of the even-valued terms that are less than a given number. In this example, if the given numb
then the sum of even-valued terms would be 2+8+34=44.

Exercise 0 (10 points). Write a function, even_fib_sum(n), that takes a specific value, n, as input, and returns the sum of the even-valued Fi
sequence terms that do not exceed n.

For example:

even_fib_sum(100) = 44 ( = 2 + 8 + 34)
even_fib_sum(200) = 188 ( = 2 + 8 + 34 + 144)

Keep in mind that we are not interested in the nth term in the sequence, but simply the Fibonacci numbers that are strictly less than n.

In [ ]: def even_fib_sum(n):
# You may assume that maximum > 0

### BEGIN SOLUTION

a, b, tot = 1, 1, 0
while b < n:
if b % 2 == 0:
tot += b
a, b = b, a + b
return tot
### END SOLUTION

In [ ]: # Test cell: test_even_fib_sum

assert even_fib_sum(2) == 0, "even_fib_sum(2) did not correctly return 0."

assert even_fib_sum(3) == 2, "even_fib_sum(3) did not correctly return 2."
assert even_fib_sum(100) == 44, "even_fib_sum(100) did not correctly return 44."
assert even_fib_sum(1000000) == 1089154, "even_fib_sum(1000000) did not correctly return 1089154
assert even_fib_sum(4000000) == 4613732, "even_fib_sum(4000000) did not correctly return 4613732
print("\n(Passed!)")

Fin! You've reached the end of this problem. Don't forget to restart the kernel and run the entire notebook from top-to-bottom to make sure you
everything correctly. If that is working, try submitting this problem. (Recall that you must submit and pass the autograder to get credit for your w
Problem 3
This problem has a single exercise worth a total of ten (10) points.

Exercise 0 (10 points). Define a function, UniqueCharacters(s), that given a string s returns a tuple of two elements: the first element is the
unique alphabetic characters in the string and the second is the number of unique digits (base-10) in the string.

For example, the string 'ewwwffioj122434' should output the following tuple: (6, 4). The 6 occurs because there are 6 unique letters ('e
'i', 'o', and 'j') and 4 because there are 4 unique numbers ('1', '2', '3', '4'). Special characters may appear in the string but do not co
or number.

In [ ]: def UniqueCharacters(s):
### BEGIN SOLUTION
return (len(set([i for i in s if i.isalpha()])),
len(set([i for i in s if i.isdigit()])))
### END SOLUTION

In [ ]: # Test Cell: 'UniqueCharacters' (10 points)

assert UniqueCharacters('abc123') == (3,3)
assert UniqueCharacters('abc') == (3,0)
assert UniqueCharacters('aaa') == (1,0)
assert UniqueCharacters('aaa111') == (1,1)
assert UniqueCharacters('111') == (0,1)
assert UniqueCharacters('123') == (0,3)
assert UniqueCharacters('') == (0,0)
assert UniqueCharacters('///;;;...,????!!!!!###$$$%%%') == (0,0)
assert UniqueCharacters('//23bd') == (2,2)
assert UniqueCharacters('b2b3n4s4d9') == (4,4)
assert UniqueCharacters('9090909p0y90p90y90') == (2,2)
assert UniqueCharacters('ieowjfiojfioj2342io4ji') == (6,3)
assert UniqueCharacters('ewwwffioj122434') == (6,4)
assert UniqueCharacters('dwdj2ru3jf894jgf.,/23,4./3ei8fj2389ej89/,.,./2dd32je98dej89ij') == (9,5
print("\n(Passed!)")

Fin! You've reached the end of this problem. Don't forget to restart the kernel and run the entire notebook from top-to-bottom to make sure you
everything correctly. If that is working, try submitting this problem. (Recall that you must submit and pass the autograder to get credit for your w

Problem 4
This problem consists of a single exercise worth ten (10) points.

Exercise 0 (10 points). Complete the function flatten(L), which takes a "complex list," L, as input and returns a "flat" copy.

By complex, we mean that the input list L consists of arbitrarily nested lists of strings and integers. For instance, here is a complex list:

L = [['a', ['cat'], 2],[[[3]], 'dog'], 4, 5]

Observe that there are strings and integers, but that these may be embedded within lists inside lists inside lists...

Given such a list, your computational task is to extract all the strings and integers, and return them in a single flattened list. For example:

assert flatten(L) == ['a', 'cat', 2, 3, 'dog', 4, 5]

In your flattened version, the strings and integers must appear in the same "left-to-right" order as they do in the original list. For instance, if you
the square brackets in the definition of L above, then observe that 'cat' appears to the right of 'a', and 2 appears to the right of 'cat', and
the right of 2, etc.

Hint: One reasonable approach to this problem is to use recursion, that is, the idea of a function that calls itself to solve subproblems. S
"Recursive programs" at the Wikipedia page on Recursion as it is used in computer science
(https://en.wikipedia.org/wiki/Recursion_%28computer_science%29#Recursive_programs).

In [ ]: def flatten(L):
assert type(L) is list
### BEGIN SOLUTION
flatList = []
for i in L:
if type(i) is not list:

flatList
flatList += [i]
i My solution: with the unpacking operator: *
 flatList += [i]
else:
flatList += flatten(i)
return flatList
### END SOLUTION

In [ ]: # Test cell: test_flatten (10 points)

L = [['a',['cat'],2],[[[3]],'dog'],4,5]
FL = flatten(L)
True_L = ['a', 'cat', 2, 3, 'dog', 4, 5]
print("Your result: \n{}".format(FL))
print('True result: \n{}'.format(True_L))
assert type(FL) is list and FL == ['a', 'cat', 2, 3, 'dog', 4, 5]
print("\n")

L = [[1,[['b'],2],'t',[[3]],'snow'],'x',['hat',7]]
FL = flatten(L)
True_L = [1, 'b', 2, 't', 3, 'snow', 'x', 'hat', 7]
print("Your result: \n{}".format(FL))
print('True result: \n{}'.format(True_L))
assert type(FL) is list and FL == [1, 'b', 2, 't', 3, 'snow', 'x', 'hat', 7]
print("\n")

L = ['x',1,'z']
FL = flatten(L)
True_L = ['x',1,'z']
print("Your result: \n{}".format(FL))
print('True result: \n{}'.format(True_L))
assert type(FL) is list and FL == ['x',1,'z']
print("\n")

L = []
FL = flatten(L)
True_L = []
print("Your result: \n{}".format(FL))
print('True result: \n{}'.format(True_L))
assert type(FL) is list and FL == []

print("\n(Passed!)")

Fin! You've reached the end of this problem. Don't forget to restart the kernel and run the entire notebook from top-to-bottom to make sure you
everything correctly. If that is working, try submitting this problem. (Recall that you must submit and pass the autograder to get credit for your w

In [ ]:

Problem 5: Pair counts

This problem consists of a single exercise worth ten (10) points.

Exercise 0 (10 points). Given a list of integers, find the number of pairs that are consecutive.

For example, given the list, [1, 2, 5, 8]:

the pairs that can be formed from the given list are (1, 2), (1, 5), (1, 8), (2, 5), (2, 8), (5, 8);
the only pair that has consecutive integers is (1, 2) and hence the value to be returned is one (1).

If elements in the list are repeated, they should be treated as members of a distinct pair. For instance, if the list were [1, 1, 1, 2, 2, 5, 8
there are three ways to choose 1 and two ways to choose 2, or a total of ways to choose the pair (1, 2), so that the answer would
be 6.

The first test case below tests for the correctness of the solution whereas the second one tests for the efficiency of the solution. That is, it shou
long for the second case to pass! (To get "full credit," try to find a method that takes less than two (2) seconds on the test input of the second t

Application note. Although this might seem like a toy problem to solve, its application forms the basis of pattern recognition. For examp
suppose you are trying to discover the buying pattern of products in a supermarket and want to figure out if placing two products next
each other impact each others' sales. (Does placing milk next to cereal drive both their sales upwards? Or if placing Muesli next to Cer
lead to additional Muesli sales, since people who buy cereal would anyway buy Milk even if it is in the other corner of the store?)

In mapping that concrete placement problem into this abstract analysis problem, you can think of the list of numbers as the shelf numb
products in a receipt and you are trying to find out the number of cases where the products were in adjacent shelves
 products in a receipt, and you are trying to find out the number of cases where the products were in adjacent shelves.

If we didn’t have the duplicates to account for, this line

In [ ]: import numpy as np
import CPSol as cp of code would have worked:
sum(a+1==b for a,b in zip(L, L[1:]))
In [ ]: def count_pairs(L):
assert type(L)==list But we need to account for duplicates, so Counter.
### BEGIN SOLUTION
# For one approach, see the "reference" in CPSol.py, included in this repo.

# Here is a faster method:

from collections import Counter
counts = Counter(L)
unique_items = sorted(counts.keys())
unique_pairs = zip(unique_items[1:], unique_items[:-1])
unit_diff_combos = [counts[b]*counts[a] for b, a in unique_pairs if (b-a) == 1]
return sum(unit_diff_combos)
### END SOLUTION

In [ ]: # Test cell: Test_Code1

def test_code1():
L1=[1,2,3,4,5,6,7,8,9]
L2=[1,1,1,2,2,3,4,10]
L3=[1,4,7,9]
L4=[]
assert count_pairs(L1)==8, "Test Case L1 failed"
assert count_pairs(L2)==9, "Test Case L2 failed"
assert count_pairs(L3)==0, "Test Case L3 failed"
assert count_pairs(L4)==0, "Test Case L4 failed"

print("\n(Passed!)")

test_code1()

In [ ]: # Test cell: Test_Code2

# This test case will test the efficieny of your solution. If it takes too long (>2 min) to run
# please try improving your method.

import numpy as np
biglist = list(np.random.choice(100, 5000, replace=True))

print("Checking correctness on a large, random list...")

result1 = cp.count_pairs_soln(biglist)
result2 = count_pairs(biglist)
assert result1 == result2
print("(Passed correctness check!)")

print("\nChecking speed...")
timing = %timeit -o count_pairs(biglist)
assert timing.average < 2.0
print("(Passed timing check!)")

Fin! You've reached the end of this problem. Don't forget to restart the kernel and run the entire notebook from top-to-bottom to make sure you
everything correctly. If that is working, try submitting this problem. (Recall that you must submit and pass the autograder to get credit for your w

Problem 6: Anagram-orama
This problem consists of a single exercise worth ten (10) points.

The code below imports a list of 10,000 common words in the English language and saves it as "commonwordslist".

In [ ]: commonwordslist = ['aa', 'aaa', 'aaron', 'ab', 'abandoned', 'abc', 'aberdeen', 'abilities', 'abi
le', 'aboriginal', 'abortion', 'about', 'above', 'abraham', 'abroad', 'abs', 'absence', 'absent
 le', 'whom', 'whore', 'whose', 'why', 'wi', 'wichita', 'wicked', 'wide', 'widely', 'wider', 'wid
'widespread', 'width', 'wife', 'wifi', 'wiki', 'wikipedia', 'wild', 'wilderness', 'wildlife', 'w
ll', 'william', 'williams', 'willing', 'willow', 'wilson', 'win', 'wind', 'window', 'windows',
indsor', 'wine', 'wines', 'wing', 'wings', 'winner', 'winners', 'winning', 'wins', 'winston', 'w
ire', 'wired', 'wireless', 'wires', 'wiring', 'wisconsin', 'wisdom', 'wise', 'wish', 'wishes',
'wit', 'witch', 'with', 'withdrawal', 'within', 'without', 'witness', 'witnesses', 'wives', 'wiz
, 'wma', 'wn', 'wolf', 'woman', 'women', 'womens', 'won', 'wonder', 'wonderful', 'wondering', 'w
den', 'woods', 'wool', 'worcester', 'word', 'wordpress', 'words', 'work', 'worked', 'worker', 'w
'workflow', 'workforce', 'working', 'workout', 'workplace', 'works', 'workshop', 'workshops', 'w
n', 'world', 'worldcat', 'worlds', 'worldsex', 'worldwide', 'worm', 'worn', 'worried', 'worry',
'worship', 'worst', 'worth', 'worthy', 'would', 'wound', 'wow', 'wp', 'wr', 'wrap', 'wrapped',
'wrestling', 'wright', 'wrist', 'write', 'writer', 'writers', 'writes', 'writing', 'writings',
'wrong', 'wrote', 'ws', 'wt', 'wto', 'wu', 'wv', 'ww', 'www', 'wx', 'wy', 'wyoming', 'x', 'xanax
'xerox', 'xhtml', 'xi', 'xl', 'xml', 'xnxx', 'xp', 'xx', 'xxx', 'y', 'ya', 'yacht', 'yahoo', 'ya
ha', 'yang', 'yard', 'yards', 'yarn', 'ye', 'yea', 'yeah', 'year', 'yearly', 'years', 'yeast',
'yemen', 'yen', 'yes', 'yesterday', 'yet', 'yield', 'yields', 'yn', 'yo', 'yoga', 'york', 'yorks
u', 'young', 'younger', 'your', 'yours', 'yourself', 'youth', 'yr', 'yrs', 'yu', 'yugoslavia',
'z', 'za', 'zambia', 'zdnet', 'zealand', 'zen', 'zero', 'zimbabwe', 'zinc', 'zip', 'zoloft', 'zo
s', 'zoning', 'zoo', 'zoom', 'zoophilia', 'zope', 'zshops', 'zu', 'zum', 'zus', "'"]

Exercise 0 (10 points). Your task is to write a function that takes any string as an input, and returns a list of any anagrams---that is, words mad
same letters---for that string that appear on the common words list.

If the string happens to be a word from the common words list, it should appear in the output. So, for instance, if the input were the string "wei
output should be ['weird', 'wider', 'wired']. If there are no anagrams for the given input, your function should return an empty list.

Bonus challenge. Can you augment your code to find the longest anagram pair in the common words list? What about the longest ana
triple, i.e., three words with exactly the same letters?

In [ ]: def anagram_check(word):
assert type(word) is str
### BEGIN SOLUTION
from collections import defaultdict
word_dic = defaultdict(list)
for aword in commonwordslist:
word_dic[''.join(sorted(aword))].append(aword)
sorted_word = ''.join(sorted(word))
return word_dic[sorted_word]
### END SOLUTION

In [ ]: # Test cell: test_dummy

assert set(anagram_check("weird")) == {'weird', 'wider', 'wired'}

assert set(anagram_check("aegllry")) == {'allergy', 'gallery', 'largely'}
assert anagram_check("this string is way too long to possibly have a match") == []

print("\n(Passed!)")

Fin! You've reached the end of this problem. Don't forget to restart the kernel and run the entire notebook from top-to-bottom to make sure you
everything correctly. If that is working, try submitting this problem. (Recall that you must submit and pass the autograder to get credit for your w

Mysolution
Problem 7
Letter frequencies. This problem has three (3) exercises worth a total of ten (10) points.

Letter frequency in text has been studied in cryptoanalysis, in particular frequency analysis. Linguists use letter frequency analysis as a rudimen
technique for language identification, where it's particularly effective as an indicator of whether an unknown writing system is alphabetic, syllab
ideographic.

Primarily, three different ways exist for letter frequency analysis. Each way generally results in very different charts for common letters. Based o
text, the first method is to count letter frequency in root words of a dictionary. The second way is to include all word variants when counting, su
going and goes and not just the root word go. Such a system results in letters like "s" appearing much more frequently. The last variant is to co
based on their frequency in the actual text that is being studied.

For more details, refer to the link: https://en.wikipedia.org/wiki/Letter_frequency (https://en.wikipedia.org/wiki/Letter_frequency)

In this problem, we will focus on the 3rd methodology.

Exercise 0 (2 points). First, given a string input, define a function preprocess that returns a string with non-alphabetic characters removed an
alphabets converted into a lower case.

For example, 'We are coding letter Frequency! Yay!" would be transformed into "wearecodingletterfrequencyyay"
solution islonger
my
In [ ]: def preprocess(S):
### BEGIN SOLUTION
s = ''.join([c.lower() for c in S if c.isalpha()])
return s
### END SOLUTION

In [ ]: # Test cell: valid_string

import random, string

N_str = 100 #Length of random string

def generate_str(n):
random_str = ''.join(random.choice(string.ascii_lowercase + string.ascii_uppercase + string.
tring.punctuation) for _ in range(n))
return random_str

def check_preprocess_str(n):
random_str = generate_str(n)
print("Input String: ",random_str)
assert preprocess('random_str').islower() == True
assert preprocess(random_str).isalpha() == True
print("|----Your function seems to work correct for the string----|"+"\n")

check_preprocess_str(N_str)
check_preprocess_str(N_str)
check_preprocess_str(N_str)

print("\n(Passed)!")

Exercise 1 (4 points). With the necessary pre-processing complete, the next step is to write a function count_letters(S) to count the numb
occurrences of each letter in the alphabet.

You can assume that only letters will be present in the input string. It should output a dictionary and if any alphabet (a-z) is missing in the input
should still be a part of the output dictionary and its corresponding value should be equal to zero.

Mysolution uses counter

In [ ]: def count_letters(S):
### BEGIN SOLUTION
alphabets = string.ascii_lowercase
count_dict = {c:S.count(c) for c in alphabets}
return count_dict
### END SOLUTION

In [ ]: # Test cell: count_letters

 import collections

N_processed_str = 100

def generate_processed_str(n):
random_processed_str = ''.join(random.choice(string.ascii_lowercase) for _ in range(n))
return random_processed_str

def check_count_letters(S):
print("Input String: ",S)
random_char = chr(random.randint(97,122))
print("Character frequency evaluated for: ", random_char)
if(random_char in S):
assert count_letters(S)[random_char] == collections.Counter(S)[random_char]
print("|----Your function seems to return correct freq for the char----|"+"\n")
else:
assert count_letters(S)[random_char] == 0
print("|----Your function seems to return correct freq for the char----|"+"\n")

check_count_letters(generate_processed_str(N_processed_str))
check_count_letters(generate_processed_str(N_processed_str))
check_count_letters(generate_processed_str(N_processed_str))
print("\n(Passed)!")

Exercise 2 (4 points). The next step is to sort the distribution of a dictionary containing all the letters in the alphabet as keys and number of occ
text as associated value.

Sorting should be first done in decreasing order by occurrence count and for two elements with same count, the order should be alphabetic. Th
find_top_letter(d) should return the 1st character in the order.

In [ ]: def find_top_letter(d):
### BEGIN SOLUTION
My solution
t = [(l, o) for l,o in d.items()]
t.sort(key = lambda x: (x[1]*-1, x[0]))
return t[:1][0][0]
### END SOLUTION

In [ ]: # Test cell: highest_freq_letter

def create_random_dict():
max_char_value = random.randint(5, 20)
random_dict = {c:random.randint(0,max_char_value-1) for c in string.ascii_lowercase}
random_letter1, random_letter2 = random.sample(string.ascii_lowercase, 2)
random_dict[random_letter1], random_dict[random_letter2] = max_char_value, max_char_value
if(random_letter1 < random_letter2):
return random_letter1, random_dict
else:
return random_letter2, random_dict

def check_top_letter():
top_letter, random_dict = create_random_dict()
user_letter = find_top_letter(random_dict)
assert user_letter == top_letter
print("Input Dictionary: ", random_dict)
print("Your function correctly returned most frequent letter: {} \n".format(user_letter))

check_top_letter()
check_top_letter()
check_top_letter()
print("\n(Passed)!")

Fin! You've reached the end of this problem. Don't forget to restart the kernel and run the entire notebook from top-to-bottom to make sure you
everything correctly. If that is working, try submitting this problem. (Recall that you must submit and pass the autograder to get credit for your w

Problem 8
This problem has three (3) exercises worth a total of ten (10) points.

Invert a dictionary. Suppose a group of student TAs have been asked to monitor the Piazza forums for your CSE6040x course. The assignmen
follows.

In [ ]: assignments = {"Monday" : ["Jeh", "Ben", "Chinmay", "Rachel"],

"Tuesday" : ["Rachel", "Samuel", "Evan", "Raghav"],
 Tuesday : [ Rachel , Samuel , Evan , Raghav ],
"Wednesday" : ["Evan", "Samuel", "Michael", "Chinmay"],
"Thursday" : ["Jeh", "Michael", "Ben", "Evan"],
"Friday" : ["Rachel", "Shishir", "Samuel", "Ben"],
"Saturday" : ["Yandi", "Michael", "Chinmay", "Samuel"],
"Sunday" : ["Evan", "Chinmay", "Jeh", "Rachel"]
}

Exercise 0 (5 points). Write a function, invert_dict(d), that "inverts" a given dictionary d. The output should be another dictionary such tha
the TA names and their corresponding values should be a list which stores the days assigned to them.

For example, one of the keys of the returned dictionary should be "Jeh" with its corresponding list as ["Monday", "Thursday", "Sunday

In [ ]: from collections import defaultdict

def invert_dict(d):
### BEGIN SOLUTION My solution
l = []
for k, v in d.items():
l.append(v)
flatten_l = [i for e in l for i in e]
flatten_l = set(flatten_l)
d_inv = defaultdict(list)
for e in flatten_l:
for k, v in d.items():
if e in v:
d_inv[e].append(k)
return dict(d_inv)
### END SOLUTION

In [ ]: # Test cell: `test_inverse`

import random
TA_list = ["Rachel", "Yandi", "Ben", "Jeh", "Evan", "Chinmay", "Shishir", "Raghav", "Samuel", "M

# Your solution
inv_dict = invert_dict(assignments)

random_TA = random.sample(TA_list, 5)
for TA in random_TA:
assigned_days = inv_dict[TA]
for days in assigned_days:
assert TA in assignments[days], "Incorrect inversion for TA {}".format(TA)

print("\n(Passed!)")

Exercise 2 (2 points): Tracing the route of a pilot.

Suppose a pilot flies from one city to the next. He makes 7 such trips, which are stored in the list shown in the next cell. The first entry of each t
the origin, and the second denotes the destination. Also assume that the next flight a pilot makes must originate from the destination of her pre
Your task in this exercise is to write a function that finds the route followed by the pilot, given her first port of origin.

First, let segments be an unordered list of segments that the pilot flew.

In [ ]: segments = [("JFK", "DEN"), ("LAX", "ORD"), ("DEN", "SFO"), ("LAS", "LAX"), ("ORD", "ATL"), ("AT
), ("SFO", "LAS")]

Next, write a function find_dest(segs, origin) that returns the next destination of the pilot given one port of origin and an unordered list
segments. Example, if segs == segments as defined above, then for 'LAX', your function should return 'ORD' because there is the tuple, (
"ORD"), in segs.

You may assume that origin appears only once in the list of segments, segs.

In [ ]: def find_dest(segs, origin):

assert type(origin) is str
assert type(segs) is list
### BEGIN SOLUTION
for i in segs:
if i[0] == origin:
dest = i[1]
return dest
### END SOLUTION

In [ ]: # Test flight destination

den = find_dest(segments, "DEN")
assert find_dest(segments, "DEN") == "SFO", "Wrong destination for DEN"
assert find_dest(segments, "LAX") == "ORD", "Wrong destination for LAX"
assert find_dest(segments, "ATL") == "JFK", "Wrong destination for ATL"
assert find_dest(segments, "JFK") == "DEN", "Wrong destination for JFK"
print("\n(Passed.)")

Exercise 3 (3 points). Now write a function get route(segs, origin) that traces the complete itinerary of the pilot, given her first port of o
Exercise 3 (3 points). Now write a function get_route(segs, origin) that traces the complete itinerary of the pilot, given her first port of o
that the destination for a flight is the same as the origin for the next flight. The itinerary is completed when he arrives back at the starting port o
example, if the starting port is "JFK", your function should return the list: ["JFK", "DEN", "SFO", "LAS", "LAX", "ORD", "ATL"].

In [ ]: def get_route(path, origin):

### BEGIN SOLUTION
route = [origin]
My solution
dest = find_dest(path, origin)
while dest != origin:
route.append(dest)
dest = find_dest(path, dest)
return route
### END SOLUTION

In [ ]: # Test pilot route

ports = ["JFK", "DEN", "SFO", "LAS", "LAX", "ORD", "ATL"]
starting_port = random.sample(ports, 5)
for p in starting_port:
itinerary = get_route(segments, p)
assert itinerary[0] == p, "incorrect port of origin for the itinerary"
for i, port in enumerate(itinerary[:-1]):
dest = find_dest(segments, port)
assert dest == itinerary[i+1], "incorrect itinerary"

print("\n(Passed.)")

Fin! You've reached the end of this problem. Don't forget to restart the kernel and run the entire notebook from top-to-bottom to make sure you
everything correctly. If that is working, try submitting this problem. (Recall that you must submit and pass the autograder to get credit for your w

Problem 9
This problem consists of a single exercise worth ten (10) points.

Exercise 0 (10 points): Write a funtion, digitize(n), that, given a postive number n, returns the digits of n as the integer elements of a list in
order.

For example:

assert digitize(1345328) == [8, 2, 3, 5, 4, 3, 1]

My solution
In [ ]: def digitize(n):
assert n > 0, '`n` is not a positive number'
assert type(n) is int, '`n` must be an `int`'
### BEGIN SOLUTION
digits = [int(d) for d in str(n)]
return digits[::-1]
### END SOLUTION

In [ ]: # Test_cell: test_digitize

assert digitize(1345328) == [8, 2, 3, 5, 4, 3, 1], 'Wrong output. Make sure your function return
ts in reverse order'
print("\n(Passed!)")

Fin! You've reached the end of this problem. Don't forget to restart the kernel and run the entire notebook from top-to-bottom to make sure you
everything correctly. If that is working, try submitting this problem. (Recall that you must submit and pass the autograder to get credit for your w
Problem 10: Tic-Tac-Toe!
The objective of this exercise is to check whether you can declare a winner based on the current state of a Tic-Tac-Toe (TTT) game
(https://en.wikipedia.org/wiki/Tic-tac-toe (https://en.wikipedia.org/wiki/Tic-tac-toe)).

A state in the game of TTT can be represented as a list of lists as follows

1. Crosses are represented by -1

2. Circles are represented by +1
3. Unused cells are represented by 0
837
For example, the game below
I o
col0 col1 col2

row0 0 0 -1

row1 1 -1 1

row2 -1 1 0

can be represented as a list of lists

[[0,0,-1],
[1,-1,1],
[-1,1,0]]

Exercise 0 Write a function called check_ttt(game) that takes a list of 3 lists representing each row of a game's state and determines wheth
is a winner. In particular, it should return one of the following strings:

1. "Circles (+1) Win"

2. "Crosses (-1) Win"
3. "No Result"

For example,

assert check_ttt([[0,0,-1],[1,-1,1],[-1,1,0]]) == "Crosses (-1) Win"

since there are three crosses (-1 values) along one of the diagonals of this board state.

You may assume that the input is a valid game state, i.e., a list representing a grid with all cells having values in and at most o
winner.

In [ ]: def check_ttt(game):
# Check that the input is valid
assert type(game) == list
assert all([type(row) == list for row in game])
assert all([[elem in [0,1,-1] for elem in row] for row in game])

### BEGIN SOLUTION

# Check for horizontal and vertical sums
for num in range(3):
hor_sum = sum(game[num])
vert_sum = sum([vert[num] for vert in game])
if max(hor_sum,vert_sum)==3: return "Circles (+1) Win"
elif min(hor_sum,vert_sum)==-3: return "Crosses (-1) Win"

# Check for diagonals

diag_for = sum([diag[i] for i,diag in enumerate(game)])
diag_back = sum([diag[2-i] for i,diag in enumerate(game)])
if max(diag_for,diag_back)==3: return "Circles (+1) Win"
elif min(diag_for,diag_back)==-3: return "Crosses (-1) Win"

return "No Result"

### END SOLUTION

In [ ]: # Test cell: test_cell_part0

import random
import numpy as np

# test 1
test_game1 = [[0,0,0] for elem in range(3)]
assert check_ttt(test_game1) == "No Result"

# test 2
test_game2 = [[1,1,1],[-1,-1,0],[0,0,0]]
assert check_ttt(test_game2) == "Circles (+1) Win"

# test 3
test_game3 = [[0,0,-1],[1,-1,1],[-1,1,0]]
assert check_ttt(test_game3) == "Crosses (-1) Win"

# test 4
test game4 [[0 0 1] [1 1 1] [1 1 1]]
 test_game4 = [[0,0,-1],[1,-1,-1],[1,1,-1]]
assert check_ttt(test_game4) == "Crosses (-1) Win"

print("\n(Passed!)")

In [ ]: # Test cell: test_cell_part1

import random
import numpy as np

def test_check_ttt():
test_game_random = [[0,0,0] for elem in range(3)]
boxes_filled = random.randint(0,8)
num_circles = int(boxes_filled/2)

circle_ind = random.sample(range(9),num_circles)
cross_ind = random.sample([elem for elem in range(9) if elem not in circle_ind],(boxes_fille
les))

for elem in circle_ind: test_game_random[int(elem/3)][elem%3] = 1

for elem in cross_ind: test_game_random[int(elem/3)][elem%3] = -1
print(np.array(test_game_random))
print("\nYour Result: {}".format(check_ttt(test_game_random)))

your_answer = check_ttt(test_game_random)
if 3 in np.sum(test_game_random,axis=0) & -3 in np.sum(test_game_random,axis=0): pass
elif 3 in np.sum(test_game_random,axis=1) & -3 in np.sum(test_game_random,axis=1): pass
elif 3 in np.sum(test_game_random,axis=0) & -3 in np.sum(test_game_random,axis=1): pass
elif 3 in np.sum(test_game_random,axis=0) & -3 in np.sum(test_game_random,axis=1): pass
elif 3 in np.sum(test_game_random,axis=0): assert your_answer == "Circles (+1) Win"
elif -3 in np.sum(test_game_random,axis=0): assert your_answer == "Crosses (-1) Win"
elif 3 in np.sum(test_game_random,axis=1): assert your_answer == "Circles (+1) Win"
elif -3 in np.sum(test_game_random,axis=1): assert your_answer == "Crosses (-1) Win"
elif np.trace(test_game_random) == 3: assert your_answer == "Circles (+1) Win"
elif np.trace(test_game_random) == -3: assert your_answer == "Crosses (-1) Win"
elif np.flipud(test_game_random).trace() == 3: assert your_answer == "Circles (+1) Win"
elif np.flipud(test_game_random).trace() == -3: assert your_answer == "Crosses (-1) Win"
else: assert check_ttt(test_game_random) == "No Result"

print("testing function for random game states..")

for i in range(20):
print("---------- Game State {} ----------".format(i))
test_check_ttt()

print("\n(Passed!)")

Fin! You've reached the end of this problem. Don't forget to restart the kernel and run the entire notebook from top-to-bottom to make sure you
everything correctly. If that is working, try submitting this problem. (Recall that you must submit and pass the autograder to get credit for your w

My attempt at sowing
or transpose s test the rows