Assignment 9-18-10 - FibonacciCalculator / FibonacciTest

Assignment  9-18-10 - FibonacciCalculator / FibonacciTest

/*
*/

public class FibonacciCalculator
{
//reverse declaration of method Fibonacci
public long fibonacci( long number )
{
if((number ==0)||(number ==1))     //base cases
return number;
else                    //recursion step
return fibonacci( number-1) + fibonacci(number-2);
}

public void displayFibonacci()
{
for (int counter=0; counter<=10; counter++)
System.out.printf("Fibonacci of %d is %d\n", counter, fibonacci(counter)
);
}
}



/*
*/
public class FibonacciTest
{
public static void main(String args[])
{
FibonacciCalculator fibonacciCalculator=new FibonacciCalculator();
fibonacciCalculator.displayFibonacci();
}
}

Assignment - DeckofCards

Assignment - DeckofCards

// Fig. 20.10: DeckOfCards.java
// Card shuffling and dealing with collections method shuffle.
import java.util.List;
import java.util.Arrays;
import java.util.Collections;

// class to represent a cards in a deck of cards
class Card
{
public static enum Face { Ace, Deuce, Three, Four, Five, Six,
Seven, Eight, Nine, Ten, Jack, Queen, King };
public static enum Suit { Clubs, Diamonds, Hearts, Spades };

private final Face face; // face of card
private final Suit suit; // suit of card

// two-arment constructor
public Card( Face cardFace, Suit cardSuit )
{
face = cardFace; // initialize face of card
suit = cardSuit; // initialize suit of card
} // end two-argument Card constructor

// return face of the cards
public Face getFace()
{
    return face;
} // end method getFace

// return suit of Card
public Suit getSuit()
{
    return suit;
} // end method getSuit

// return String representation of Card
public String toString()
{
    return String.format( "%s of %s", face, suit );
} // end method toString
} // end class card

// class DeckOfCards declaration
public class DeckOfCards
{
    private List< Card > list; // declare List that will store Cards

    // set up deck of Cards and shuffle
    public DeckOfCards()
    {
        Card[] deck = new Card[ 52 ];
        int count = 0; // number of cards

        // populate deck with card objects
        for ( Card.Suit suit : Card.Suit.values() )
        {
            for ( Card.Face face : Card.Face.values() )
            {
                deck[ count ] = new Card( face, suit );
                ++count;
            } // end for
        } // end for
        list = Arrays.asList( deck ); // get List
        Collections.shuffle( list ); // shuffle deck
    } // end DeckOfCards constructor

    // output deck
    public void printCards()
    {
        // display 52 cards in two columns
        for ( int i = 0; i < list.size(); i++ )
        System.out.printf( "%-19s%s", list.get( i ),
        ( ( i + 1 ) % 4 == 0 ) ? "\n" : "" );
    } // end method printCards

    public static void main( String[] args )
    {
        DeckOfCards cards = new DeckOfCards();
        cards.printCards();
    } // end main
} // end class DeckOfCards

Assignment 14 - MergeSort / Test

Assignment 14 - MergeSort / Test and Image Result

/*

//Merge Sort

*/

import java.util.Random;

public class MergeSort
{
private int[] data; //array of values
private static Random generator = new Random();

//create array of given size and fill with random integers
public MergeSort( int size )
{
data = new int[size]; //create space for array

//fill array with random ints range 10-99
for( int i = 0; i < size; i++ )
data[i] = 10 + generator.nextInt( 90 );
}

//calls recursive split method to begin merge sorting
public void sort()
{
sortArray( 0, data.length - 1); //split entire array
}

//splits array, sort subarrays and merges subarrays into sorted array
private void sortArray( int low, int high )
{   
//test case: size of array equals 1
if( ( high - low ) >= 1 ) //if not base case
{
int middle1 = (low + high )/2; //calculate middle of array
int middle2 = middle1 + 1; //calculate next element over

//output split step
System.out.println( "split: " + subarray( low, high ) );
System.out.println( " " + subarray( low, middle1 ) );
System.out.println( " " + subarray( middle2, high ) );

//split array in half; sort each half of array
sortArray( low, middle1 ); //first half of array
sortArray( middle2, high ); //second half of array

//merge 2 sorted arrays after split calls return
merge( low, middle1, middle2, high );
}
}

//merge 2 sorted subarrays into one sorted sub array
private void merge( int left, int middle1, int middle2, int right )
{
int leftIndex = left; //index into left subarray
int rightIndex = middle2; //index into right subarray
int combinedIndex = left; //index into temp. work array
int[] combined = new int[data.length]; //working array

//output 2 subarrays before merging
System.out.println( "merge: " + subarray( left, middle1 ) );
System.out.println( " " + subarray( middle2, right ) );

//merge arrays until reaching end of either
while( leftIndex <= middle1 && rightIndex <= right )
{
//place smaller of 2 current elements into result
//and move to next space in arrays
if( data[leftIndex] <= data[rightIndex] )
combined[combinedIndex++] = data[leftIndex++];
else
combined[combinedIndex++] = data[rightIndex++];
}

//if array is empty
if( leftIndex == middle2 )
//copy in rest of right array
while( rightIndex <= right )
combined[combinedIndex++] = data[rightIndex++];
else
//copy in rest of left array
while( leftIndex <= middle1 )
combined[combinedIndex++] = data[leftIndex++];

//copy values back into original array
for( int i = left; i <= right; i++ )
data[i] = combined[i];

//output merged array
System.out.println(" " + subarray( left, right ) );
System.out.println();

}

//method to output certain values in array
public String subarray( int low, int high )
{
StringBuilder temporary = new StringBuilder();

//output spaces for alignment
for( int i = 0; i < low; i++ )
temporary.append( "" );

//output elements left in array
for( int i = low; i <= high; i++ )
temporary.append( "" + data[i] );

return temporary.toString();
}

//method to output values in array
public String toString()
{
return subarray( 0, data.length - 1 );
}
}



/*

//main function

*/

public class MergeSortTest
{
public static void main( String[] args )
{
//create object to perform merge sort
MergeSort sortArray = new MergeSort(10);

//print unsorted array
System.out.println( "Unsorted: " + sortArray + "\n" );

sortArray.sort(); //sort array

//print sorted array
System.out.println( "Sorted: " + sortArray );
}
}

Assignment 13 - InsertionSort / Test

Assignment 13 - InsertionSort / Test

/*
   Assignment 13
  Insertion Sort
*/

import java.util.Random;


public class InsertionSort
{
    private int[] data; //array of values
    private static Random generator = new Random();

    //create array of given size to fill
    public InsertionSort( int size )
    {
        data = new int[size]; //create space for arrays

        //fill arrays with random numbers 10-99
        for( int i = 0; i < size; i++ )
            data[i] = 10 + generator.nextInt(90);
    }

    //sort array using insertion sort
    public void sort()
    {
        int insert; //temp; variable to hold element to insert

        //loop over data.length - elements
        for( int next = 1; next < data.length; next++ )
        {
            //sort value in current element
            insert = data[next];

            //initialize location to palce element
            int moveItem = next;

            //search for place to put current element
            while( moveItem > 0 && data[moveItem - 1] > insert )
            {
                //shift element right one slot
                data[moveItem] = data[moveItem - 1];
                moveItem--;
            }

            data[moveItem] = insert; //place inserted element
            printPass( next, moveItem ); //output pass of algorithm
        }
    }

    //print a pass of the algorithm
    public void printPass( int pass, int index )
    {
        System.out.print( String.format( "after pass %2d: ", pass ) );

        //output elements till swapped item
        for( int i = index + 1; i < data.length; i++ )
            System.out.print( data[i] + " ");

        System.out.print( "\n             " ); //for allignment

        //indicate amount of array that is sorted
        for( int i = 0; i <= pass; i++ )
            System.out.print( "-- " );
        System.out.println( "\n" ); //add endline
    }

    //method to output values in array
    public String toString()
    {
        StringBuilder temporary = new StringBuilder();

        //iterate through array
        for ( int element : data )
            temporary.append( element + " " );


        temporary.append( "\n" ); //add endline character
        return temporary.toString();
    }
}

/*
  Assignment 13   
  main function
*/
public class InsertionSortTest
{
    public static void main( String[] args )
    {
        //create object to preform insertion sort
        InsertionSort sortArray = new InsertionSort( 10 );

        System.out.println( "Unsorted array: " );
        System.out.println( sortArray ); //print unsorted array

        sortArray.sort();

        System.out.println( "Sorted array: " );
        System.out.println( sortArray ); //print sorted array
    }
}

Assignment 12 - SelectionSort / Test

Assignment 12 - SelectionSort / Test and Image Result

/*

//Selection Sort Algorithm
*/

import java.util.Random;

public class SelectionSort
{
private int[] data; //array of value
private static Random generator = new Random();

//create array if given size and fill w/ random int
public  SelectionSort( int size)
{
data = new int[size]; //create space for array

//fill array with random int 10-99
for( int i = 0; i < size; i++ )
data[i] = 10 + generator.nextInt( 90 );
}

//sort array using selection sort
public void sort()
{
int smallest; //index of smallest element

//loop over data length -1
for (int i = 0; i < data.length - 1; i++)
{
smallest = i; //first index of remaining array

//loops to find index of smallest element
for (int index = i + 1; index < data.length; index++)
if( data[index] < data[smallest])
smallest = index;

swap( i, smallest); //swap smallest elements into position
printPass( i + 1, smallest );
}
}

//helper method to swap values intwo elements
public void swap( int first, int second )
{
int temporary = data[first]; //store first in temporary
data[first] = data[second]; //replace first in second
data[second] = temporary; // put temporary in second
}

//print a pass of algorithm
public void printPass( int pass, int index )
{
System.out.print( String.format( "after pass %2d: ",pass) );

//output elements till selected itme
for (int i=0; i < index; i++)
System.out.print( data[i] + " ");

System.out.print( "\n      "); //for alignment

//indicate amount of array that is sorted
for( int j = 0; j < pass; j++ )
System.out.print("--");
System.out.println("\n"); //add endline
}

//method to output values in array
public String toString()
{
StringBuilder temporary = new StringBuilder();

//iterate through array
for (int element : data)
temporary.append( element + " " );

temporary.append("\n");
return temporary.toString();
}
}

/*

//main function
*/

public class SelectionSortTest
{
public static void main( String[] args )
{
//create object to preform selection sort
SelectionSort sortArray = new SelectionSort(10);

System.out.println( "Unsortoed array:");
System.out.println( sortArray ); //print unsorted array

sortArray.sort(); //sort array

System.out.println( "Sorted Array:");
System.out.println( sortArray ); //print sorted array
}
}

Assignment 360 - Towers of Hanoi / Test

Assignment 360 - Towers of Hanoi / Test and Image result

/*
Towers of Hanoi
*/


public class TowersOfHanoi
{
private int numDisks; //number od idsks to move

public TowersOfHanoi( int disks )
{
numDisks = disks;
}

//recursively more diks between towers
public void solveTowers( int disks, int sourcePeg, int destinationPeg, int tempPeg)
{
//base case -- only one disk to move
if(disks == 1)
{
System.out.printf( "\n%d --> %d", sourcePeg, destinationPeg);
return;
}

//recursing step -- move (disk - 1) disks from sourcePeg
//to tempPEg using destinationPeg
solveTowers( disks - 1, sourcePeg, tempPeg, destinationPeg );

//move last disk from sourcePeg to destinationPeg
System.out.printf( "\n%d --> %d", sourcePeg, destinationPeg);

//move (disks - 1) disks from tempPeg to destinationPeg
solveTowers( disks - 1, tempPeg, destinationPeg, sourcePeg);
}
}

 TowersOfHanoiTest

/*
main function to be run
*/

public class TowersOfHanoiTest
{
public static void main( String args[] )
{
int startPeg = 1; //value 1 used to indicate startPeg in output
int endPeg = 3; //value 3 used to indicate endPeg in output
int tempPeg = 2; //value 2 used to indicate tempPeg output
int totalDisks = 3; // number of disks
TowersOfHanoi towersOfHanoi = new TowersOfHanoi( totalDisks );

//initial nonrecursive call: move all disks
towersOfHanoi.solveTowers( totalDisks, startPeg, endPeg, tempPeg );
}
}

Assignment 1 9/30/10 FactorialCalculator and FactorialTest

Assignment 1 9/30/10 FactorialCalculator and FactorialTest with results

/*
Assignment 1 09/30/10
*/

public class FactorialCalculator
{
//recursive declaration on method factorial
public long factorial( long number )
{
if (number <=1 ) //test for base case
return 1; //base cases: 0!=1 and 1!=1
else //recursion step
return number * factorial(number - 1);
}

//output factorials for values 0-10
public void displayFactorials()
{
//calculate factorials of 0 thourhg 10
for (int counter = 0; counter <= 10; counter++)
System.out.printf( "%d! = %d\n", counter, factorial( counter ) );
}
}

/*
Fig 15.4
9/18/07
*/

public class FactorialTest
{
//calculate factorials of 0-10
public static void main( String args[] )
{
FactorialCalculator factorialCalculator = new FactorialCalculator();
factorialCalculator.displayFactorials();
}
}