 Graphic by Keith Ohlfs |
|
|
Graphic by Keith Ohlfs |
|
The purpose of this problem set is to give you practice with recursion. There is one pencil-and-paper problem and two programming problems (one in BuggleWorld and one in TurtleWorld). You can find the support code for the programming problems in the ps5_programs folder in the CS111 download folder.
With the introduction of conditionals last week and recursion this week, programming has become much more challenging than on your first few assignments. It is a good idea to think carefully about how to solve your problems before you sit down at a computer and start writing code. It has been our experience that attempting to solve these sorts of problems while sitting at the computer is a recipe for disaster, because it can easily turn into a frustrating trial-and-error nightmare. Instead, we suggest that you form study groups and talk about solution strategies with your classmates before attempting to write any code. Once you have settled upon a strategy, we suggest that you write your Java code first using pencil and paper and simulate it in your head to check for its correctness. Only as a last step should you type in your code and test it on the computer.
We have including working examples of the solutions to the programming problems in the Test folder that you download with the ps5_programs folder. It is a good idea to run these programs to get a feel for what we are asking you to do. Your solution should provide the exact same results as our solution (except as noted below).
Softcopy submission: Save the modified
SierpinksiWorld.java and QuiltWorld.java
files in the ps5_programs folder. Upload the entire
folder (including all the other .java and
.class files -- everything) to your ps5 drop folder.
Hardcopy submission: Turn in only one package of hardcopy materials. Staple your files together and submit your hardcopy package by placing it in the box outside of Lyn's office (121B, behind the mini-focus consultant's desk). Your package should include:
SierpinksiWorld.java from Homework Problem 2
QuiltWorld.java from Homework Problem 3
Reminders
The following recursive method is defined for the Recurser subclass of Buggle, which can be found in the file RecursionWorld.java within the Recursive Buggles folder of the lec11_programs folder:
public void spiral (int n) {
if (n > 0) {
forward(n);
left();
spiral(n - 1);
right();
backward(n);
}
}
Consider the following run() method in the RecursionWorld subclass of BuggleWorld:
public void run () {
Recurser rita = new Recurser();
rita.spiral(3);
}
Draw a Java Execution Model diagram that shows all of the execution frames created by invoking the run() method on an instance of the the RecursionWorld class. Your diagram should depict the point in time when the invocation of run() returns. Although Java can discard an execution frame when control returns from it, you should not discard any frames when drawing your diagram.
In order to distinguish the state of rita at various points in time, you should follow the convention used in the Friday, October 15 lecture for showing the state of a buggle at a particular point in time. That is, you should use a labelled column of variables to represent one state of a buggle, as shown below, where the names s1, s2, s3, ... label the states.
|
|
|
|
|
|
|
Position |
|
|
|
|
|
Heading |
|
|
|
|
|
Color |
|
|
|
|
|
BrushDown? |
|
|
|
|
If rita is in the same state at different points in time, you may reuse an existing state column rather than creating a new one. When evaluating a variable that refers to rita in the code portion of an execution frame, you should denote the value as R@si , where R (which should be circled) denotes rita and si denotes the state that rita was in when control evaluated the variable.
Please follow the usual conventions for drawing Java Execution Model diagrams. Strive to make your diagram as neat as possible.
Sierpinski's gasket is a self-similar triangular entity discovered in 1916 by Polish mathematician Waclaw Sierpinski (1882-1969). In this problem we will investigate an approach for approximating Sierpinski's gasket.
Let sierpinski(levels, side) be the notation for a Sierpinski gasket with levels levels and side length side. Then a recursive mathematical definition of sierpinski is as follows:
The pictures below depict sierpinski(levels, side) for for levels = 1 through 5. These are approximations to the "true" self-similar Sierpinksi gasket, which is the limit of sierpinski(levels, side) as levels approaches infinity.
|
|
|
|
|
|
In this problem you will define a Java method that uses a turtle to draw Sierpinski's gasket. To begin this problem, download the SierpinskiWorld folder from the ps5_programs folder in the CS111 download folder. The file SierpinskiWorld.java contains a subclass of Turtle named SierpinskiMaker with a stub for the following method:
public void sierpinski (int levels, double side) {
// Draw a sierpinski gasket specified by levels and side.
// Maintain the invariant that the turtle's position and heading after
// a call to sierpinski are the same as before the call to sierpinski.
}
Flesh out the definition of the sierpinski method so that it draws the specified Sierpinski gasket and maintains the turtle's position and heading as invariants. Note: SierpinskiWorld.java includes code that creates an instance of SierpinskiMaker and positions it toward the lower left hand corner of the screen facing east. A gasket whose lower left-hand corner is positioned at this starting point will be automatically centered in the TurtleWorld window.
Test your definition by specifying levels and side in the parameter window and then clicking on the Run button in the TurtleWorld window. The Reset button will clear the screen. Good parameter values are in the ranges [0 ... 8] for levels and [100 ... 400] for side. If your program hangs, you may need to "force quit" it by depressing the option, apple, and escape keys all at the same time.
Recall that the Turtle drawing primitives include the following:
public void fd (double n) Move the turtle forward n steps. public void bd (double n); Move the turtle backward n steps. public void lt (double angle); Turn the turtle to the left angle degrees. public void rt (double angle); Turn the turtle to the right angle degrees. public void pu (); Raise the turtle's pen up. public void pd (); Lower the turtle's pen down.
Additionally, there are also versions of fd, bd, lt, and rt that take int parameters, so you can invoke these methods with either an integer or double floating-point value.
You should not need to use any other Turtle primitives other than those listed above. In fact, many solutions use only a subset of the primitives listed above.
Quilt sales at the Buggle Bagel Ruggle Company have been flat recently. The market researchers at the company have determined that one factor accounting for the sluggish sales is the limited number of quilt sizes and quilt patterns offered by the company. In contrast, the recursively structured quilt patterns of their main competitor, the PictureWorld Quilt Company, have been selling like hotcakes.
To help improve sales, Quinton Buggle, the chief quilt designer at Buggle Rug, has developed a recursive bagel quilt pattern that can be used on a rug of any size. Here are examples of his pattern on square rugs with side lengths 16, 17, 18, and 19:
|
|
|
|
|
|
|
|
|
|
The fundamental repeated unit in these quilts is a triangle of bagels of size n, where n measures the number of bagels on a side. Here is such a triangle for n = 8:
Given a square rug with dimensions m x m, bagel triangles of size (m/2) are placed at the corners, and then the pattern is repeated in the smaller square bounded by the outer bagels in the center of the rug. Here (m/2) means integer division, as performed by Java. If m is odd, the result is truncated down to the nearest integer. For example, both 6/2 and 7/2 yield 3. Note that if m is even, all border cells of the square are covered with bagels, but if m is odd, the middle cell of each side of the square will not contain a bagel. Quinton has decided that the smallest square that should contain bagels is a 3x3 square. So the pattern is empty when applied to 1x1 and 2x2 squares.
In this problem, you are given a skeleton of the QuiltBuggle class and asked to define the following method in this class:
public void quilt(int side)
Assume that the buggle starts in the lower left-hand corner of a square whose side length is side, facing parallel to the bottom side. Drops bagels to form Quinton's pattern within this square, and returns to its initial position and heading.
Your quilt method should work for any integer; it should do nothing for side lengths <= 2. It should be defined recursively. You will need to define numerous auxiliary methods, many of which themselves will be recursive.
You should write all your definitions within the QuiltBuggle class, which can be found in the file QuiltWorld.java within the Quilt folder of the ps5_programs folder. You can test your code by running the QuiltWorld.html applet. In addition to the usual BuggleWorld window, this applet displays a parameter window that allows you to change the side length of the BuggleWorld grid. Pressing the Reset button causes the grid to have the side length specified in the parameter window.
The Test subfolder of the ps5_programs folder contains a working version of QuiltWorld.html that you can play with. Your solution should produce the same quilt designs as this test applet. It's worth noting that there are many possible ways to correctly decompose the problem, and the test applet uses only one possible approach. Thus, while you must produce the same designs as the test applet, you need not produce the designs in the same way as the test applet.