Graphic by Keith Ohlfs

CS111, Wellesley College, Fall 1997 Problem Set 5: Recursion Note Extension: Due: Saturday, November 8, 6pm

[CS111 Home Page] [Syllabus] [Students] [Lecture Notes] [Assignments] [Programs] [Documentation] [Software Installation] [FAQ] [CS Dept.] [CWIS]

In this problem set, you will explore two problems that involve recursion.

Problem 1: Bagel Bush

A bagel bush is a recursive figure defined by the function BagelBush(levels, size), where

• BagelBush(0, size) is an empty figure.
• BagelBush(1,size) is a line consisting of size+1 grid cells, whose last grid cell contains a bagel.
• BagelBush(levels, size) (where levels >= 2) is a line consisting of size+1 grid cells, whose last cell is the origin of three orthogonal bagel bushes specified by BagelBush(levels - 1, size/2).

Below are some examples of some bagel bushes in a 16x16 grid. In all cases, there is a North-pointing buggle at position (8,1).

BagelBush(0,8)	BagelBush(1,8)
BagelBush(2,8)	BagelBush(3,8)
BagelBush(4,8) or BagelBush(5,8) or BagelBush(6,8), etc.	BagelBush(3,4) or BagelBush(4,4) or BagelBush(5,4), etc.

The fact that bagel bushes are drawn on a discrete grid means that resolution can be lost. Assume that all fractional numbers are rounded down to the nearest integer, and that many parts of the tree can share the same grid cell. For example, as illustrated above, BagelBush(n,8) is the same for all n >= 4. In order to get better resolution, it is necessary to use a grid with more cells. For example, here is BagelBush(5,16):

To begin this problem, download the BagelBush folder from the CS111 download folder on Nike. Rename the BagelBush folder username_BagelBush, where username is your Nike username. You do not need to rename any other files within the BagelBush folder.

The BagelBush class creates an n x n grid, and places a Northward-pointing buggle named bertha at position (n/2, 1), where n is a variable whose value you can edit (by default it is 16). Bertha is sent the message bush(levels, size), where levels and size are numbers you can edit; by default they are 4 and 8, respectively.

Bertha is a member of the BagelBusher subclass of Buggles, which responds to the following method:

public void bush (int levels, int size)
  Use this buggle to draw the bagel bush defined by BagelBush(levels, size).

Your goal is to flesh out the bush skeleton so that it correctly draws the bagel bushes illustrated in the pictures above.

Notes/suggestions:

• bush should be defined as a recursive method.
  
  
• It is important to maintain the following invariant: a buggle should be in exactly the same state (i.e. position and heading) upon exiting a call to bush as it is when it enters a call to bush.
  
  
• The bush skeleton contains two calls to System.out.println: one for when the method is entered, and one for when the method is exited. These may help you debug your method. Comment them out if they get in the way.
  
  
• Bertha should not "dance" or "jiggle" when drawing the bagel "leaves" of the bush. Avoiding dancing requires thinking carefully about base cases. (Do not spend too much time trying to avoid dancing. A dancing bush drawer is way better than no bush drawer!)
  
  
• If you think about base cases carefully, it should not be necessary to use the test isOverBagel(). But you may use it if you cannot otherwise avoid it. (A buggle using isOverBagel() will almost certainly do unnecessary dancing.)
  
• In addition to the usual buggle window, there is a Bagel Bush Parameter window that allows you to change the parameters n, levels, and size without recompiling the program.

When you are done with this problem, submit the entire username_BagelBush folder to your ps5 drop folder on Nike.

Problem 2: Quilts Revisited

Consider the following quilt patterns:

On problem set 3, you wrote methods that produced the quilts shown above. (The "exploding" pattern in the upper right corner has been slightly modified to simplify this problem.) Each quilt required multiple methods that usually differed only in the number of patches they drew (e.g. 16x16, 8x8, 4x4, etc).

In this problem, you will use the power of recursion to define, for each quilt pattern, a single method that draws that quilt pattern. In a few cases, you will be provided with some auxiliary methods to help draw the pattern.

To begin this problem, download both the Patchwork folder and the Quilts folder from the CS111 download folder on Nike. Rename the Quilts folder username_Quilts, where username is your Nike username. You do not need to rename any other files within the Quilts folder. You do not need to rename the Patchwork folder.

Study the files Patchwork.java and PatchworkRecursive.java within the Patchwork folder. Patchwork.java contains the patchwork-drawing code presented in class during Lecture 9 (September 30, 1997). PatchworkRecursive.java contains recursive versions of the patchwork-drawing code presented in class during Lecture 17 (October 30, 1997). Note how recursion greatly simplifies the patchwork-drawing code.

Next study the file Quilts.java within the Quilts folder. This file contains the solutions to Problem Set 3 (modulo the minor change to the Explode pattern).

Finally, examine the file QuiltsRecursive.java. This file contains stubs for the following four method definitions:

     public void drawStripes (int n, Graphics g, Color c1, Color c2, 
	                          int side, int x, int y)
	  Draw horizontal stripes in nxn patches within a square at (x,y) with length side.
	  The stripes alternate between colors c1 and c2. 
	  All stripes are n patches wide. The height of the stripes in patches decreases 
	  in the sequence n/2, n/4, n/8, etc. 
 
     public void drawExplode (int n, Graphics g, int side, int x, int y)
	  Draw an "exploding" pattern using nxn patches in a square at (x,y) with length side.
	  The upper left quadrant is a solid color, while the other three quadrants are
	  exploding patterns. Use the intToColor method to determine the color of the
	  solid square for a given n.
 
	public void drawWeave (int n, Graphics g, Color c1, Color c2, Color c3, 
	                         int side, int x, int y)
	  Draw a weave pattern with straw colors c1 and c2 and background color c3
	  within the nxn patches of a square at (x,y) with length side. 
	  Use the drawWeave2x2a and drawWeave2x2b methods to draw the primitive
	  2x2 weave patterns.
 
	public void drawDiagonals (int n, Graphics g, Color c1, Color c2, Color c3, 
	                             int side, int x, int y)
	  Draw lower-left to upper-right diagonals in  within nxn patches in a 
	  square at (x,y) with length side. The main diagonal of the square should
	  be color c1, and from right to left the colors should alternate in the
	  sequence c1, c2, c3, c1, c2, c3, etc.  Note that the recursive pattern 
	  differs when n is 1 mod 3 (i.e. (n % 3) == 1)  and when n is 2 mod 3
	  (i.e. (n % 3) == 2). 
 

You are to flesh out the definitions of these above four methods so that the following paint method draws the four quilts in the picture at the beginning of this problem.

	public void paint(Graphics g){
	  this.drawStripes(16, g, Color.yellow, Color.red, 160, 0, 0);
	  this.drawExplode(16, g, 160, 200, 0);
	  this.drawWeave(16, g, Color.yellow, Color.black, Color.white, 160, 0, 200);	
        this.drawDiagonals(16, g, Color.red, Color.blue, Color.yellow, 160, 200, 200);
	}
 

You should define each of the four methods recursively. Think carefully about the base case(s) and general case(s) for each method.

Notes/hints:

• You should only define the four methods specified above. However, you have been provided with some auxiliary methods (defined below) that will simplify your definitions. You should not define any new auxiliary methods.
  
  
• You have been provided with the following drawSolid method discussed in class:

	public void drawSolid (int n, Graphics g, Color c, int side, int x, int y) {
        Draw nxn patches of color c in the square with length side at  point (x,y).
	  Assume that n is 2a, where a >= 0.

• In drawExplode, you should use the provided intToColor method to determine the color of the upper left quadrant. This method maps integers to colors. In particular, it maps 16 to yellow, 8 to red, 4 to blue, 2 to green, and all other integers to black.
  
  
• For drawWeave, you have been provided with methods drawWeave2x2a and drawWeave2x2b that draw the primitive 2x2 weaving patterns. You should invoke these methods in the base case of drawWeave.
  
  
• In drawDiagonals, you will need a different recursive decomposition when n is 1 mod 3 than when n is 2 mod 3. (The notation "x is a mod b" means that a divided by b leaves a remainder of x.) In Java, the binary arithmetic operator % computes remainders. For example, 5%2 is 1, 5%3 is 2, and 5%5 is 0. So you should have different recursive decompositions for the cases (n%3 == 1) and (n%3 == 2). Think carefully about why this is the case; it may help to study the diagonal-drawing code in Quilts.java.

When you are done with this problem, submit the entire username_Quilts folder to your ps5 drop folder on Nike.