Work Hours
Everyday: 北京时间8:00 - 23:59
Task 1 – Secret Messages
Can you guess what the encoded message below says?
Tha rein in Spein fells meinly in tha mounteins, not pleins
If you got it, nice work! If not, don’t worry – you’ll have a program to do this very
soon! The answer is, “The rain in Spain falls mainly in the mountains, not plains”, and
we can get this by replacing all of the e’s in the encoded message with a’s, and viceversa. (i.e. A ↔ E)
Let’s try another one. Can you guess what the message below says?
I lofe ctudying artivisial intelligense
This one is harder, because there are two pairs of swapped letters: V ↔ F and S ↔ C.
If we reverse these swaps, then the answer is, “I love studying artificial intelligence”,
(which we really hope is true! ). One more puzzle: if you start with the message,
“Cabs are taxis.”, and you apply the swaps A ↔ B, and then B ↔ C, what encoded
message would you get?
The answer is, “Bcas cre tcxis”
- Start: Cabs are taxis
- Swap A ↔ B: Cbas bre tbxis (adjust colour)
- Swap B ↔ C: Bcas cre tcxis (adjust colour)
Notice that the encoded messages so far still resemble the original message,
because we haven’t swapped many letters. However, if we continue to add swaps,
the messages will become harder to read, so it would be nice to have a program to
help us out.
For this task, you will write a function to encode and decode messages using the
above letter swapping method (which is the how the secret message in the
introduction was encoded). The function should have three parameters:
- A string specifying the key (i.e. the sequence of letter swaps). For example,
“AEGHAG”, would mean we should apply the swaps A ↔ E, G ↔ H, then A ↔
G if we’re encoding, or the reverse (A ↔ G, G ↔ H, then A ↔ E) if we’re
decoding. Note that “AEGHAG” is the same as “EAGHAG”, since A ↔ E is the
same as E ↔ A. - The name of a text file containing the message to be encoded or decoded.
- Either ‘e’ or ‘d’ indicating whether to encode or decode, respectively.
The function will return the resulting encoded or decoded message as a string, with
capitalisation, punctuation and spacing preserved. Here are some example calls to
the function:
print(task1(‘AE’, ‘spain.txt’, ‘d’))
The rain in Spain falls mainly in the mountains, not plains.
print(task1(‘VFSC’, ‘ai.txt’, ‘d’))
I love studying artificial intelligence.
print(task1(‘ABBC’, ‘cabs_plain.txt’, ‘e’))
Bcas cre tcxis.
Program.py
def task1(key, filename, indicator):
#TODO
return ”
if name == ‘main‘:
# Example function calls below, you can add your own to test the task1 function
print(task1(‘AE’, ‘spain.txt’, ‘d’))
print(task1(‘VFSC’, ‘ai.txt’, ‘d’))
print(task1(‘ABBC’, ‘cabs_plain.txt’, ‘e’))
Task 2 – Search Space
Congratulations! We can now encrypt and decrypt messages if we have the key (i.e.
the sequence of letters to swap). However, what happens if we don’t have the key?
Well, as the name of this assignment suggests, we’ll have to search for one! In this
task, we’ll look at how we can represent our search space as a tree and we’ll also
work on a program to generate child nodes for that tree. This will be very helpful
when we come to implement our search algorithms later.
Before starting, let’s revise the key elements of a search problem from the lecture
slides:
Figure 1: The four elements of search problem formulation (COMP3308/3608 W2 slides)
In our case, the initial state is the encrypted message. Can you work out what each
of the other elements (i.e. goal state, operators and path cost function) should be?
The answers are—wait! Are you sure you want to read on? Thinking about these
questions is a great exercise (and helpful for the exam 😊). If yes, the answers are
as follows: 1) the goal state is the decoded message, 2) the operators are the letter
swaps (e.g. A ↔ E), since these transform messages into other messages and 3) the
path cost is the number of letter swaps (e.g. if we applied A ↔ E, then E ↔ B, that
would have a cost of 2.
Now that we have formulated our search problem, we can start setting up tools to
help us with the search. In this task, you will write a function to find all of the
successors of a state in our search space, given a set of allowed letters to swap. The
function should have two parameters:
- The name of a text file containing the parent state
- A string containing all letters that are allowed to be swapped. For example,
“ABC” would mean A ↔ B, A ↔ C and B ↔ C are allowed, but nothing else.
Note that we are adding this condition so we can make the state space
smaller, which will help with debugging. This will also be useful when we
come to decoding the secret message.
The function will return a string which includes the number of successor states,
followed by a list of these states separated by lines. The successors should be
generated by applying the allowed operators in alphabetical order. For example, all of
the A swaps (e.g. A ↔ B, A ↔ C, A ↔ D… etc.) should come before the B swaps (e.g.
B ↔ C, B ↔ D, B ↔ E etc.). Additionally, A ↔ B should come before A ↔ C., since B
comes before C. There is no need to include repeats (e.g. we don’t need B ↔ A, since
it is the same as A ↔ B), or operators that do nothing (e.g. A ↔ A always does
nothing, and A ↔ B does nothing if the message doesn’t contain any A’s or B’s).
Some examples are given below.
print(task2(‘spain.txt’, ‘ABE’))
3
Thb rein in Spein fells meinly in thb mounteins, not pleins.
The rain in Spain falls mainly in the mountains, not plains.
Tha rbin in Spbin fblls mbinly in tha mountbins, not plbins.
print(task2(‘ai.txt’, ‘XZ’))
0
print(task3(‘cabs.txt’, ‘ABZD’))
5
Acbs cre tcxis.
Bcds cre tcxis.
Bczs cre tcxis.
Dcas cre tcxis.
Zcas cre tcxis.
Note: you can adapt your code from Task 1 to help you here.
Program.py
def task2(filename, letters):
#TODO
return ”
if name == ‘main‘:
# Example function calls below, you can add your own to test the task2 function
print(task2(‘spain.txt’, ‘ABE’))
print(task2(‘ai.txt’, ‘XZ’))
print(task2(‘cabs.txt’, ‘ABZD’))
Task 3 – Goal
Excellent work! Now that we have our successor state program, we’re almost ready
to search! We just need one more ingredient – a goal test! In this task, you will write
a function to check if a given message is valid English, by comparing it to a common
English word list. The function should take three inputs:
- The name of a text file containing the message
- The name of a text file containing a list of words, in alphabetical order and
each on a separate line, which will act as a dictionary of correct words - A threshold, t, specifying what percentage of words must be correct for this to
count as a goal (given as an integer between 0 and 100). The threshold is
important, because we may need a buffer if our dictionary is missing words,
or there are some misspelt words in the message.
The function should return a string containing two lines of text. The first line should
be “True” if at least t% of the words in the message are correct according to the
dictionary and “False” otherwise. The second line should be the percentage of words
that were correct, to 2 decimal places (round off any further decimal places; 0.005
rounds up to 0.01). Some examples are given below.
print(task3(‘jingle_bells.txt’, ‘dict_xmas.txt’, 90))
True
90.00
print(task3(‘fruit_ode.txt’, ‘dict_fruit.txt’, 80))
False
50.00
print(task3(‘amazing_poetry.txt’, ‘common_words.txt’, 95))
True
95.65
Dictionary matching is case insensitive; if the dictionary contained only the word
‘apple’, then ‘Apple’, ‘apple’, and ‘aPPle’ in the message should all count as correct
words according to the dictionary. Words are separated by whitespace (space and
newline characters).
Program.py
def task3(message_filename, dictionary_filename, threshold):
#TODO
return ”
if name == ‘main‘:
# Example function calls below, you can add your own to test the task3 function
print(task3(‘jingle_bells.txt’, ‘dict_xmas.txt’, 90))
print(task3(‘fruit_ode.txt’, ‘dict_fruit.txt’, 80))
print(task3(‘amazing_poetry.txt’, ‘common_words.txt’, 95))
Task 4 – DFS, BFS, IDS, UCS
Fantastic! We now have tools to help us generate children and to perform goal
checks. In this task, you will now combine all your work so far to write a function to
perform uninformed searches. It should take six inputs:
- A character (d, b, i or u) specifying the algorithm (DFS, BFS, IDS and UCS,
respectively)- The name of a text file containing a secret message
- The name of a text file containing a list of words, in alphabetical order and
each on a separate line, which will act as a dictionary of correct words- A threshold, t, specifying what percentage of words must be correct for this to
count as a goal (given as an integer between 0 and 100).- A string containing the letters that are allowed to be swapped
- A character (y or n) indicating whether to print the messages corresponding
to the first 10 expanded nodes.
It should then perform DFS, BFS, IDS or UCS to search for a decryption to the given
message, reusing your code from previous tasks if you would like to. Note that
children should be generated in the same order as in Task 2, and you do not need to
handle cycles. In the case of UCS, if two nodes have the same priority for expansion,
you should expand the node that was added to the fringe first, first. Additionally, you
should stop the search if 1000 nodes have been expanded without finding a solution.
The function should return a string. This string must contain the following
information, in order:- The decrypted message, key for generating that message and the path cost, if
a solution was found. If no solution was found, the program should print, “No
solution found.”- The number of nodes expanded during the search. Note that the start node
counts as an expanded node and, in the case of IDS, the final expanded node
count should be the sum of the expanded node counts on each iteration.- The maximum number of nodes in the fringe at the same time during the
search- The maximum search depth reached. That is, the depth of the deepest
expanded node. Note that the start node has a depth of 0, and its children
have depths of 1.- (If indicated with y) the messages corresponding to the first 10 expanded
nodes in the search. If less than 10 nodes were expanded, it should print all
expanded nodes.
Some examples of function calls and results are given below.
print(task4(‘d’, ‘cabs.txt’, ‘common_words.txt’, 100, ‘ABC’, ‘y’))
No solution found.
Num nodes expanded: 1000
Max fringe size: 2001
Max depth: 999
First few expanded states:
Bcas cre tcxis.
Acbs cre tcxis.
Bcas cre tcxis.
Program.py
def task4(algorithm, message_filename, dictionary_filename, threshold, letters,
debug):
#TODO
return ”
if name == ‘main‘:
# Example function calls below, you can add your own to test the task4 function
print(task4(‘d’, ‘cabs.txt’, ‘common_words.txt’, 100, ‘ABC’, ‘y’))
print(task4(‘b’, ‘cabs.txt’, ‘common_words.txt’, 100, ‘ABC’, ‘y’))
print(task4(‘i’, ‘cabs.txt’, ‘common_words.txt’, 100, ‘ABC’, ‘y’))
