Examine this pattern of asterisks and blanks and write a recursive method that can generate exactly this pattern:

*
* *
  *
* * * *
    *
    * *
      *
* * * * * * * *
        *
        * *
          *
        * * * *
            *
            * *
              *

With recursive thinking, the method needs only seven or eight lines of ode (including two recursive calls). How is this pattern a fractal? Your method should also be capable of producing larger or smaller patterns of the same variety. Hint: Have two parameters. One parameter indicates the indentation of the leftmost line in the pattern; the other parameter indicates the number of stars in the longest line.

WARNING: Cheating is bad, mmmmkay children? Don’t cheat.

 /*
|	Bryan Simonson
 \	CS211 - Craig Niiyama
  | 2/21/2010
*/

package bryansimonson;

public class Fractal {
	public static void main(String args[]){
		drawFractal(32,0);
	}

	public static void drawFractal(int length, int space){
		if (length==1){ // the stopping case
			for (int n=0; n<space; n++) System.out.print("  ");
			System.out.println("* ");
		} else {		// length is a power of two
			drawFractal(length/2,space);
			for (int n=0; n<space; n++) System.out.print("  ");
			for (int n=0; n<length; n++) System.out.print("* ");
			System.out.println();
			drawFractal(length/2,length/2+space);
		}
	}
}

Make improvements to the car was simulation program

from Section 7.2.

Note: Portions of code taken from Michael Main’s version.

WARNING: Cheating is bad, mmmmkay children? Don’t cheat.

 /*
|	Bryan Simonson
 \	CS211 - Craig Niiyama
  | 2/21/2010
*/

// FILE: Carwash.java
// This program illustrates the use of the carWashSimulate method which uses
// a simple queue to simulate cars waiting at a car wash.
package bryansimonson;
import java.io.*;
import java.util.LinkedList;
import java.util.Queue;
import edu.colorado.simulations.BooleanSource;
import edu.colorado.simulations.Washer;
import edu.colorado.simulations.Averager;

/******************************************************************************
* The <CODE>CarWash</CODE> Java application illustrates the use of
* the <CODE>carWashSimulate</CODE> method.
* The illustration uses the following values:
*   <CODE>
*   <br>washTime = 240
*   <br>arrivalTime = 0.0025
*   <br>totalTime = 6000
*   </CODE>
*
* <p><dt><b>Java Source Code for this class:</b><dd>
*   <A HREF="../applications/CarWash.java">
*   http://www.cs.colorado.edu/~main/applications/CarWash.java
*   </A>
*
* @author Michael Main
*   <A HREF="mailto:main@colorado.edu"> (main@colorado.edu) </A>
*
* @version
*   Jun 12, 1998
******************************************************************************/
public class CarWash
{
   /**
   * The main method activates <CODE>carWashSimulate</CODE> with the values:
   *   <CODE>
   *   <br>washTime = 240
   *   <br>arrivalTime = 0.0025
   *   <br>totalTime = 6000
   *   </CODE>
   * <BR>The <CODE>String</CODE> argument (<CODE>args</CODE>) is not used in
   * this implementation.
   **/
   public static void main(String[ ] args) throws IOException
   {
	  BufferedReader stdin = new BufferedReader (new InputStreamReader(System.in));

	  // get total length of simulation from the user
      System.out.println("How many seconds would you like to simulate?");
      System.out.println("(Default is 6000)");
      int simtime = Integer.parseInt(stdin.readLine());

      // get the probability of a new customer from the user
      System.out.println("What is the probably of a new customer arriving in any given second?");
      System.out.println("(Default is 0.0025)");
      double probability = Double.parseDouble(stdin.readLine());

      // get the number of seconds it takes to wash the car from the user
      System.out.println("How many seconds does it take to wash one car?");
      System.out.println("(Default is 240)");
      int washtime = Integer.parseInt(stdin.readLine());

      carWashSimulate(washtime, probability, simtime);
   }

   /**
   * Simulate the running of a car washer for a specified amount of time.
   * @param <CODE>washTime</CODE>
   *   the number of seconds required to wash one car
   * @param <CODE>arrivalProb</CODE>
   *   the probability of a customer arriving in any second, for example
   *   0.1 is 10%
   * @param <CODE>totalTime</CODE>
   *   the total number of seconds for the simulation
   * <dt><b>Precondition:</b><dd>
   *   <CODE>washTime</CODE> and <CODE>totalTime</CODE> are positive;
   *   <CODE>arrivalProb</CODE> lies in the range 0 to 1.
   * <dt><b>Postcondition:</b><dd>
   *   The method has simulated a car wash where <CODE>washTime</CODE> is the
   *   number of seconds needed to wash one car, <CODE>arrivalProb</CODE> is
   *   the probability of a customer arriving in any second, and
   *   <CODE>totalTime</CODE> is the total number of seconds for the
   *   simulation. Before the simulation, the method has written its three
   *   parameters to <CODE>System.out</CODE>. After the simulation, the method
   *   has written two pieces of information to <CODE>System.out</CODE>:
   *   (1) The number of cars washed, and (2) The average waiting time for
   *   customers that had their cars washed. (Customers that are still in the
   *   queue ARE included in this average).
   * @exception java.lang.IllegalArgumentException
   *   Indicates that one of the arguments violates the precondition.
   **/
   public static void carWashSimulate
   (int washTime, double arrivalProb, int totalTime)
   {
      Queue<Integer> arrivalTimes = new LinkedList<Integer>( );
      int next;
      BooleanSource arrival = new BooleanSource(arrivalProb);
      Washer machine = new Washer(washTime);
      Averager waitTimes = new Averager( );
      int currentSecond;

      // Write the parameters to System.out.
      System.out.println("Seconds to wash one car: " + washTime);
      System.out.print("Probability of customer arrival during a second: ");
      System.out.println(arrivalProb);
      System.out.println("Total simulation seconds (open \"hours\"): " + totalTime);

      // Check the precondition:
      if (washTime <= 0 || arrivalProb < 0 || arrivalProb > 1 || totalTime < 0)
         throw new IllegalArgumentException("Values out of range"); 

      for (currentSecond = 0; currentSecond < totalTime || !arrivalTimes.isEmpty(); currentSecond++)
      {  // Simulate the passage of one second of time.

         // Check whether a new customer has arrived.
         if (arrival.query( ) && currentSecond <= totalTime)
            arrivalTimes.add(currentSecond);

         // Check whether we can start washing another car.
         if ((!machine.isBusy( ))  &&  (!arrivalTimes.isEmpty( )))
         {
            next = arrivalTimes.remove( );
            waitTimes.addNumber(currentSecond - next);
            machine.startWashing( );
         }

         // Subtract one second from the remaining time in the current wash cycle.
         machine.reduceRemainingTime( );
      }

      // Write the summary information about the simulation.
      System.out.println("Customers served: " + waitTimes.howManyNumbers( ));
      if (waitTimes.howManyNumbers( ) > 0)
         System.out.println("Average wait: " + waitTimes.average( ) + " sec");

      // Print ending second to compare to expected "closing time"
      System.out.println("Ending second (or last customer served): " + currentSecond);
   }

}

Suppose that you have n queens from a chess game, and that you also have an n-by-n chess board. Is it possible to place all n queens on the board so that no two queens are in the same row, no two queens are in the same column, and no two queens are on the same diagonal?

WARNING: Cheating is bad, mmmmkay children? Don’t cheat.

n Queens source code:

 /*
|	Bryan Simonson
 \	CS211 - Craig Niiyama
  | 2/21/2010
*/

package bryansimonson;
import edu.colorado.collections.*;

public class nQueens {
	public static void main(String[] args) {
		final int QUEENS = 40;
		queens(QUEENS);
	}

	public static void queens(int n){
		boolean success = false;

		// row = the row within the stack, column = the row's integer value
		ArrayStack<Integer> s = new ArrayStack<Integer>(n);
		s.push(1);

		while (!success && !s.isEmpty()){
			int x=0;	// placeholder for when we pop values
			boolean conflict = false;

			// check for conflicts
			for (int i=1; i<s.size(); i++){
				int deltarows = s.size()-i;
				if (	// no need to check row, stack preempts row conflict
						s.peek()==s.itemAt(i) ||			// same column
						s.peek()==s.itemAt(i)+deltarows ||	// same diagonal
						s.peek()==s.itemAt(i)-deltarows		// same diagonal
					) conflict = true;
			}

			if (conflict){
				while (s.peek()==n)
					x=s.pop();
				if (!s.isEmpty())
					s.push(s.pop()+1);
				else
					s.push(x+1);
			} else if (!conflict && s.size()==n){
				success = true;
			} else {
				// new row, so try column 1
				s.push(1);
			}
		}

		// print out the board with the queens
		for (int x=1; x<=s.size(); x++){
			for (int y=1; y<=n; y++){
				if (s.itemAt(x)==y)
					System.out.print("X ");
				else
					System.out.print("O ");
			}
			System.out.println();
		}

	}
}

PseudoRandomDemo.java

 /*
|	Bryan Simonson
 \	CS211 - Craig Niiyama
  | 1/19/2010
*/

package bryansimonson;
import bryansimonson.PseudoRandom;

/**
 * @author Bryan Simonson (manticor@gmail.com)
 */
public class PseudoRandomDemo {

	/**
	 * The main function generates a table that counts how many
	 * instances of a pseudorandom number fall within a certain range.
	 */
	public static void main(String[] args) {
		final int INTRVL = 10;				// interval of distribution table
		final int LOOPS = 1000000;			// number of times to run loop
		final int SEED = 1;					// initial seed value
		final int INCR = 3641;				// increment
		final int MOD = 729;				// modulus
		final int MULT = 40;				// multiplier
		int[] dist = new int[INTRVL];		// distribution table

		PseudoRandom x = new PseudoRandom(SEED, MULT, INCR, MOD);

		System.out.println("Output of PseudoRandomDemo");
		System.out.println();

		// Show initial values
		System.out.println("Initial values");
		System.out.println("Interval:\t"+INTRVL);
		System.out.println("Seed:\t\t"+SEED);
		System.out.println("Multiplier:\t"+MULT);
		System.out.println("Increment:\t"+INCR);
		System.out.println("Modulus:\t"+MOD);
		System.out.println();

		// Demonstrate current() function
		System.out.println("Demonstrate current() function");
		System.out.println(x.current());
		System.out.println();

		// Demonstrate next() function
		System.out.println("Demonstrate next() function");
		System.out.println(x.next());
		System.out.println(x.next());
		System.out.println(x.next());
		System.out.println();

		// Demonstrate nextMod() function
		System.out.println("Demonstrate nextMod() function");
		System.out.print("nextMod() value: ");
		System.out.printf("%6.2f",x.nextMod());
		System.out.println();
		System.out.println("new seed value:"+x.current());

		// Demonstrate changeSeed() function
		x.changeSeed(SEED);
		System.out.println("\nSeed has been reset using changeSeed("+SEED+")\n");

		// Populate array with count of instances between each interval
		for (int i = 0; i<LOOPS; i++){
			dist[(int)(x.nextMod()*INTRVL)]++;
		}

		// Print out a table with instance counts per interval
		System.out.println("Count of instances");
		System.out.println("Range\t\tNumber of Occurrences");
		for (int i=0; i<INTRVL; i++){
			System.out.println(
					"["+
					((double)(i)/INTRVL)+
					".."+
					((double)(i+1)/INTRVL)+
					")\t"+
					dist[i]
			);
		}
	}
}

PseudoRandom.java (Class)

package bryansimonson;

 /*
|	Bryan Simonson
 \	CS211 - Craig Niiyama
  | 1/19/2010
*/

/**
 * @author Bryan Simonson (manticor@gmail.com)
 *
 */
public class PseudoRandom {
	private int seed;
	private int multiplier;
	private int increment;
	private int modulus;

	/**
	 * Constructor for PseudoRandom object.
	 * @param firstseed - The original seed value
	 * @param mult - Multiplier
	 * @param incr - Increment
	 * @param mod - Modulus value
	 */
	public PseudoRandom (int firstseed, int mult, int incr, int mod){
		multiplier = mult;
		increment = incr;
		modulus = mod;
		seed = (mult * firstseed + incr) % mod;
	}

	/**
	 * Access the current seed value
	 * @return
	 * 	The current seed value
	 */
	public int current(){
		return seed;
	}

	/**
	 * Generates the next pseudorandom number iteration
	 * @return
	 * 	The next pseudorandom number iteration
	 * @postcondition
	 * 	The current seed value set to the same value that is returned
	 */
	public int next(){
		seed = (multiplier * seed + increment) % modulus;
		return seed;
	}

	/**
	 * Change the current seed value
	 * @param newseed
	 * @postcondition
	 * 	The current seed value is replaced by <code>newseed</code>
	 */
	public void changeSeed(int newseed){
		seed = newseed;
	}

	/**
	 * Generates the next pseudorandom number divided by the modulus value
	 * @return
	 * 	a double in the range [0..1)
	 * @postcondition
	 * 	the current seed value is set to whatever the next pseudorandom integer
	 */
	public double nextMod(){
		return (next()/(double)modulus);
	}
}