School of Informatics, University of Edinburgh

Transcription

1 CS1Bh Practical 1 Words and Sentences This is an individual practical exercise which requires you to submit some Java programs and some text files for assessment. A system which measures software similarity will be used to compare all of the submissions in order to detect unreasonable levels of collaboration. Your attention is drawn to the guidelines on plagiarism presented in Appendix A of the Computer Science 1 course guide. This practical is based on the material on Java programming. In particular, material on recursion and improving the efficiency of calculations by storing intermediate results for later reuse. This practical has been issued on Thursday 30th January. The deadline for your solutions is Thursday 20th February at 17:00. Your solutions must be submitted electronically from your School of Computer Science account with the handin command. No alternative methods of submission will be accepted. No late submissions will be accepted. After each use of the handin command, you should then execute the show submissions command to ensure that your practical has been submitted correctly. Execute the handin and show submissions commands from a shell window (not the KDE command run command window), so you can see any error messages which result. Note that a failure to execute the proper handin command cannot be investigated after the practical deadline, please take care to execute the command exactly as it is shown below. In particular, be sure that you use the correct practical identifiers, filenames and extensions. If in doubt, consult a laboratory demonstrator for further assistance. The practical exercises in Computer Science 1Bh are equally weighted and together they constitute 25% of the final mark for the course. Introduction: sentence checking In a variety of situations we want to check whether a given string is a sentence composed of a sequence of words drawn from some dictionary. For example, if our words are: ga, ta tc then the string gatatatctaga is a sentence composed of a sequence of these words while gattaca is not (because there is no way to get two t s together from our set of words). Generalising this we get a statement of the problem we will consider in this practical: Given a collection of words w 1,..., w k and a string s, is there a sequence i 1,..., i n for some n 0, with each 1 i j k for 1 j n, such that w i1... w in = s. 1

2 The remainder of the Practical will be taken up with studying this problem in more detail. If all we are concerned with is whether a particular string is constructed from a sequence of words the simplest approach is to construct a finite state machine to recognise any sequence of the given words. In many cases we want to do more than this e.g. to count the number of different ways of constructing a given string from the words or to specify how the string is split into words. Here we consider some of these more complex tasks. Exercise Before starting the practical you should make your own copy of the files in the directory /home/cs1/cs1/bh/pracs/wordsandsentences. You can do this efficiently by issuing the commands: cp -r /home/cs1/cs1/bh/pracs/wordsandsentences Your home directory will now contain a private directory called WordsAndSentences containing a subdirectory for each part of the practical. For Parts A and C you have to write Java code; in both cases you will need to edit a file called Match.java following the instructions below and in the file. The user interface for the program is contained in the Sentence.java files; you do not need to edit those files. To test your program, compile all the Java code in the directory and run the command: java Sentence The user interface is very primitive. It consists of three text displays, and three buttons. The Input display is where you input the dictionary words and the string to be tested. It is the only display where you can write. The Dictionary display shows the current words in the dictionary. The Results display communicates if the string can be generated by the dictionary or not, and the time it took to check it. The buttons are: Clear: This clears the Input display. Word: This adds the text in the Input display to the dictionary. The new word appears in the Dictionary display. At the moment there is no way of deleting words from the dictionary. If you want to do that you must abort the program and restart. Go: This takes the text in the Input display as the string to be tested. Notice that spaces are not discarded and trailing spaces are significant in words. The Results display shows a feedback message indicating whether the text could be constructed or not, and the running time. Part A: A simple solution and its implementation In this section we consider a very simple recursive solution to the problem. It is your responsibility to implement the solution outlined here in the class Match. The solution follows easily from the divide-and-conquer approach: A string s is acceptable if and only if 2

3 it is empty (and so it is the composition of zero of the words), or, there is a word w such that s begins with w, and the remainder of s after removing w from the front of s is acceptable. Note that this is a recursive definition, like the definition of the spell() method in Lecture Note 2. In the file Match.java in directory PartA you will find the class Match. Its objects have three private fields: A String s containing the string to be checked, a Vector words containing the words of the dictionary, and an object sent of the class Sentence. You do not need to worry about this last field, since it is only used for communication with the graphical interface. You need to define the method: public boolean check(int i) that checks if the substring of s starting at index i and continuing to the end is acceptable. (So check(0) checks if the whole string is acceptable.) In the class Sentence two methods are defined that allow us to display the state of the match by putting a boundary character between two words in the string: addboundary(i) adds a boundary just before the ith character in the string. (In particular, if you call the method with i = 0 you add a delimiter before the whole string.) delboundary() deletes the last boundary we added. You should incorporate invocations of these methods in your code for check(). At the end of the checking procedure, the Input display should show the boundaries between words in the sentence discovered by the matching. So, for instance, if the dictionary contains the words {aa, b}, then after checking aaaabaa the Input display should show aa aa b aa. (You can also add delimiters at the beginning and/or at the end of the word if you wish, i.e., aa aa b aa, aa aa b aa, or aa aa b aa are also correct outputs.) If the string cannot be matched, no boundaries should be displayed. Notice that the return value of the check() method is not displayed by the user interface. (We recommend that you first work out how to implement check without any calls to addboundary(i) and delboundary(), and then add these.) To do this part you should review the definitions of the String, Vector and Iterator classes. Familiarity with these classes will make this task much easier. When you are happy with your solution you should submit your work using the handin command: handin B1a Match.java You should use the show submissions command to ensure correct submission. Part B: Analysing the simple solution In this section you are asked to do some analysis of the implementation you developed in Part A. 3

4 1. Give a succinct description of how your implementation will behave if the collection of words is a and aa and the string is any sequence of a s followed by a b. 2. More precisely, suppose the collection of words is as in (1), and the input is n a s followed by a b. Express the number of times the check() method is invoked, using O-notation, as a function of n. Use part (1) to explain how you obtained this result. 3. A string w 1 is a prefix of a string w 2 if there is a string w such that w 1 w = w 2. We consider now collections of words in which no word is a prefix of any other (for instance, {ab, ac} is such a collection, but {a, aa} is not). These collections are sometimes called prefix collections or, more accurately, prefix-free collections. Express the number of times the check method is invoked in the worst case, using O-notation, if the input is a prefix-free collection. Justify your answer. 4. Supposing your collection of words is aa and aaaa, show by induction (see Lecture Note 6) that the number of invocations of your check method on inputs of the form a 4n a is greater than k2 n for some suitable choice of k. You should write your solutions in the file PartB.txt in the Part B subdirectory, and submit them using the command: handin B1b PartB.txt Part C: Improving the simple solution In this part of the practical you should use the files in PartC as the basis for your solution. In this case we want to count the number of different ways of constructing the string from the words and improve the efficiency of the checking process. In the file Match.java in directory PartC you will find a class that retains a collection of words and the string to be considered. You need to define the method: public int check() that calculates the number of different ways in which the string can be constructed from the words. You should use the following method: If the stored string s has length n, you should construct an array with n + 1 elements called count. The entry count[j] counts the number of different ways the substring beginning at index j and continuing to the end of s can be constructed from the words. There is exactly one way to spell the empty string with any set of words so the value stored in count[n] should be 1. The array count should then be filled in from right to left. If a word w matches the substring of s going from index i up to and including index j then count[j+1] should be added to count[i]. 4

5 As it stands your program gives the number of different ways of constructing the string from the words but does not give any example construction. Add code to your program (using the addboundary and delboundary methods mentioned in PartA) to draw in the word boundaries if they exist. (If there is more than one way in which the string can be generated from the words in the dictionary, your program should show anyone of them.) When you are happy with your solution you should submit your work using the handin command: handin B1c Match.java Part D: Further analysis and extensions In this section you are asked to do some analysis of the implementation you developed in Part C. 1. What is the worst case running time of your implementation? Justify your answer by an informal argument. 2. What is the best-case running time of your implementation? Is there any way to improve it? You should write your solutions in the file PartD.txt in the Part D subdirectory, and submit them using the command: handin B1d PartD.txt Stuart Anderson and Javier Esparza, 2003/02/07 12:12:48. 5