Homework 6: Heaps Due: 5:00 PM, Apr 9, 2018

Transcription

1 CS18 Integrated Introduction to Computer Science Fisler, Nelson Contents Homework 6: Heaps Due: 5:00 PM, Apr 9, Sifting Up and Down 2 2 Text Processing 3 3 Appendix 6 Objectives By the end of this homework, you will be able to: ˆ implement heaps, from soup to nuts ˆ use priority queues to solve problems How to Hand In For this homework, you should answer the Sifting Up and Down and Text Processing questions. In order to hand in your solutions to these problems, they must be stored in appropriately-named files with the appropriate package header in an appropriately-named directory. The source code files should comprise the hw06.src package, and your solution code files, the hw06.sol package. Begin by copying the source code from the course directory to your own personal directory. That is, copy the following files from /course/cs0180/src/hw06/src/*.scala to /course/ cs0180/workspace/scalaproject/src/hw06/src: ˆ IHeap.scala ˆ AbsHeap.scala ˆ AbsHeapTest.scala ˆ NoSiftHeapTest.scala ˆ ITextProcessor.scala ˆ FileProcessor.scala Do not alter these files! After completing this assignment, the following solution files should be in your /course/cs0180/workspace/scalaproject/sol/hw06/sol directory:

2 ˆ Sifting Heap.scala containing the declaration class Heap[T <% Ordered[T]: ClassTag](override val initcapacity: Int) extends AbsHeap[T](initCapacity) HeapTest.scala, containing class HeapTest(heap: IHeap[Int]), which your testing traits should extend; and object HeapTest, in which your tests are executed ˆ Text Processor TextProcessor.scala containing class TextProcessor(fileName: String) extends ITextProcessor tp_test.txt containing documentation of your tests for TextProcessor To hand in your files, navigate to the /course/cs0180/workspace/scalaproject/ directory, and run the command cs018 handin hw06. This will automatically hand in all of the above files. Once you have handed in your homework, you should receive an , more or less immediately, confirming that fact. If you don t receive this , try handing in again, or ask the TAs what went wrong. Priority Queues As discussed in class, a priority queue is a data structure that organizes items based on a given priority instead of a simple Last-In-First-Out (LIFO) or First-In-First-Out (FIFO) ordering. Priorities are values of some class that is Ordered (or can be viewed as such), like Ints, Doubles, etc. A priority queue is a mutable data structure. Objects join the queue in order to be serviced, and exit the queue after being serviced. To create a PriorityQueue in Scala of type String, for example you use the following syntax: import scala.collection.mutable.priorityqueue val pq = new PriorityQueue[String] Then, to add items to pq, you use +=, as follows: pq += "Hello, World!" To remove the item in the queue with the highest prority, you invoke the method dequeue, as follows: val output = pq.dequeue() For more information about Scala s priority queue API, visit the priority queue documentation page. 2

3 Problems 1 Sifting Up and Down In this problem, you will complete the implementation of heaps that was presented in class. Specifically, you will implement the necessary sifting methods to build and maintain a heap. We provide the bulk of the implementation for you, including: ˆ IHeap.scala, which is the IHeap interface ˆ AbsHeap.scala, an abstract class which stores the heap itself (i.e., the balanced array) and implements the methods in IHeap.scala The AbsHeap class implements getmin, deletemin, and insert, but it remains abstract, because it does so without a working implementation of the helpers siftup and siftdown (it only has the method stubs). Your job is to implement a working Heap by creating a concrete implementation of siftup and siftdown in the Heap class. Task: Implement a class, Heap, which extends the AbsHeap class provided. That is, implement the siftup and siftdown methods. Each should take as input an index that references an item in the heap that is possibly out of heap order, and should then restore heap order using the promotion and demotion strategies discussed in class. Note: Your class declaration for Heap should look like class Heap[T <% Ordered[T]: ClassTag ](override val initcapacity: Int) extends AbsHeap[T](initCapacity). Make sure to import scala.reflect.classtag Task: Test your heap implementation by following the testing framework laid out in Lab 9. That is, write your tests as traits that extend a basic class called HeapTest, and then mix them in when declaring an instances of HeapTest. Feel free to use some of the tests provided in the source code, but know that these tests are not fully exhaustive, so you must write your own as well. 2 Text Processing Batman is going to be busy hunting criminals and needs you to build a robotic Bruce Wayne impersonation to run Wayne Enterprises while he is gone. In order to make his robot more realistic, he needs to compile a list of his most common words so that the robot will talk like him. He asks you to do this for him by looking through his secret diary and keeping track of the words he used. Task: Write a class TextProcessor whose constructor takes as input a file name, and which implements the trait ITextProcessor, with the method textstats, that outputs to standard output (i.e., prints!): (i) the top 10 most common words in the file (ignoring capitalization), (ii) the number of times they each appear, and (iii) their proportions, relative to the other words in the document (reported to two decimal places). Feel free to use the Java I/O classes you are accustomed to using, though the Scala Standard Library does have equivalents. We have provided the File Processor object, with a gettext method, which you may use to read the text of a file into an array of Strings. Be sure to print your output 3

4 in a format that is easy to read. Keep your users (Batman, who needs to program the words into the robot 1 ) in mind. Hint: After processing the text, consider how you might use a priority queue to sort and find the most common words! Another Hint: For this problem, you might find the tolowercase method in the String class useful; it returns the string it is called upon with its uppercase letters converted to lowercase. Also recall that you can split up a string of words separated by spaces or punctuation into an array of individual words using split. For example: scala> "I love CS 18!!" split "[\\s\\w]+" Array[String] = Array(I, love, CS, 18) \s refers to any white space character (space, tab, newline, etc.), and \W refers to any nonalphanumeric character (anything but letters, numeric digits, and underscores). Note: This regex splits based on punctuation, so, for example, don t becomes don and t. This is the appropriate, expected behavior: i.e., it is okay if your program treats contractions as separate words. Task: Write a main method in the companion object of your TextProcessor, which takes as input a filename as a command-line argument, and assuming the file exists, creates a TextProcessor on which to invoke textstats. Be sure to handle errors (e.g., file not found ) gracefully. Task: As with all code you write in CS 18, we expect you to perform comprehensive testing. Since your TextProcessor writes directly to standard output, unit testing can be tricky. You should instead write system tests that comprehensively test your TextProcesser s functionality. Be sure to test more than just one corpus! Document your testing in your tp_test.txt file, and be sure to include a description of both input and expected output. Note: In order to test your implementation, you should use some test corpora. We have provided several at /course/cs0180/src/poems/, but we strongly recommend writing and testing some of your own corpora to catch edge cases and test thoroughly! Be sure to include all corpora necessary for your tests to run in your handin. We have provided benchmark results for the othello and synonym, respectively, files in the /course/ cs018/src/poems/ folder for you to compare your output. Keep in mind that testing just these two files is not sufficient! We encourage you to test your TextProcessor on more than just the given corpora to ensure full functionality. 1 and, your friendly TA staff 4

5 word count % i and the to you of a my that iago word count % guy the h dude shall wh4t het sh4ll who

6 3 Appendix Here is a class diagram indicating the structure that your solution files should have after you finish implementing heaps: trait IHeap[T] implicit coerce(t: T): Ordered[T] getmin: Option[T] deletemin: Option[T] insert(item: T) extends abstract class AbsHeap[T <% Ordered[T]: ClassTag](val initcapacity: Int) override implicit coerce(t: T): Ordered[T] protected var capacity protected var heap protected var numitems private val factor private isfull: Boolean private issparse: Boolean override isempty: Boolean override getmin: Option[T] override deletemin: Option[T] override insert(item: T) private resizearray(newcapacity: Int) swap(idx1: Int, idx2: Int) siftup(int: index) siftdown(int: index) extends class Heap[T <% Ordered[T]: ClassTag](override val initcapacity: Int) override siftup(int: index) override siftdown(int: index) Please let us know if you find any mistakes, inconsistencies, or confusing language in this or any other CS18 document by filling out the anonymous feedback form: courses/cs018/feedback. 6