Download dice - Joshua Stough

COMP 110
Introduction to Programming
Mr. Joshua Stough
October 31, 2007
Declaration vs. Instantiation
public class Dice
{
private Die[] dice;
// declaration
public Dice(int numDice)
{
dice = new Die[numDice]; // instantiation
for (int i=0; i<dice.length; i++) {
dice[i] = new Die();
}
}
creates a new local variable called dice
NOT
// declaration and instantiation
Die[] dice = new Die[numDice];
Declaration vs. Instantiation
public class Dice
{
private Die[] dice;
public Dice(int numDice)
{
dice = new Die[numDice];
for (int i=0; i<dice.length; i++) {
dice[i] = new Die();
}
}
face
this
dice
0
1
2
3
Declaration vs. Instantiation
public class Dice
{
private Die[] dice;
public Dice(int numDice)
{
Die[] dice = new Die[numDice];
for (int i=0; i<dice.length; i++) {
dice[i] = new Die();
}
}
face
dice
this
dice
0
1
2
3
Declaration vs. Instantiation
Use the debugger in jGRASP
• Set a breakpoint
• Compile in debug mode
• Press
instead of
• Step through the program and
look at the created variables
Writing Test Programs
• Die class
– constructor - takes no parameters
– getFace - returns the die's face value as int
– roll - takes no parameters, returns nothing, rolls
the die
• Tests
Die die1 = new Die();
Die die2 = new Die();
– create two Die objects
die1.roll();
– roll both Die objects
die2.roll();
– print the face value of both Die objects
System.out.println ("die1: " + die1.getFace());
System.out.println ("die2: " + die2.getFace());
DieTester.java
public class DieTester
{
public static void main (String[] args)
{
Die die1 = new Die();
Die die2 = new Die();
die1.roll();
die2.roll();
System.out.println ("die1: " + die1.getFace());
System.out.println ("die2: " + die2.getFace());
}
}
Writing Test Programs
• Dice class
– constructor - takes an int parameter (number of
dice)
– roll - takes no parameters, returns nothing, rolls
all of the dice
– getNumDie - takes no parameters, returns the
number of dice
– getDie - takes an int parameter (position),
returns the Die at that position
– toString - takes no parameters, returns String
of all of the dice's face values
Writing Test Programs
Dice dice3 = new Dice(3);
• Tests
Dice dice7 = new Dice(7);
– create a Dice object with 3 dice and another Dice
object with 7 dice
dice3.roll();
– roll all of the dice
dice7.roll();
– print the 3-dice Dice object
– print the 7-dice Dice object
System.out.println ("3 dice: " + dice3);
System.out.println ("7 dice: " + dice7);
– print the face value of the 3rd die in the 7-dice
Dice object
System.out.println ("3rd die: " +
dice7.getDie(2).getFace());
DiceTester.java
public class DiceTester
{
public static void main (String[] args)
{
Dice dice3 = new Dice(3);
Dice dice7 = new Dice(7);
dice3.roll();
dice7.roll();
System.out.println ("3 dice: " + dice3);
System.out.println ("7 dice: " + dice7);
System.out.println ("3rd die: " +
dice7.getDie(2).getFace());
}
}
Finding Pairs
0
1
2
3
4
How do you pick which ones are pairs?
How do you explain to a small child (or a
computer) how to pick which ones are
pairs?
Remember, a computer can only
compare two things at a time.
Finding Pairs
ind1
ind2
0
1-4
1
2-4
2
3-4
3
4
0
1
2
3
4
Does Die at ind1 equal Die at ind2?
length of array? 5
int len = dice.getNumDice();
for (int ind1 = 0; ind1<len-1; ind1++) {
// save face value of Die at ind1
for (int ind2 = ind1+1; ind<len; ind2++) {
// save face value of Die at ind2
// compare face values -- if match -> print
}
}
Equality
Die die1 = dice.getDie(ind1);
Die die2 = dice.getDie(ind2);
if (die1.getFace() == die2.getFace())
if (die1.equals(die2))
public boolean equals (Die otherDie)
{
if (getFace() == otherDie.getFace()) {
return true;
}
in Die class
return false;
}
New Stuff
• Searching arrays for a particular value
– reference: Ch 10 (pgs. 524-526, 537-542)
• Sorting arrays
– makes searching for a particular value
easier (and quicker)
– reference: Ch 10 (pgs. 527-534)
Searching Arrays
• Find one particular element in an array of many
elements
• Find several particular elements in an array of
many elements
• Complexity (How Long To Search?)
– find a parking space - linear
– look up a word in a dictionary - complex
• 500K+ words in OED
–
search - very complex
• over 3 trillion web pages
Linear Searching
• Given a test value and a list of values
– list can be ordered or unordered
– loop through the list
• repeatedly ask: Is this a match?
• quit when the answer is yes
(use break stmt)
– if you finish all items, there is no match
• Inefficient
– worst time to search is ~ length
– average time to search is ~ length/2
• Relatively easy to program
// Linear search of unordered list of integers
// unordered list
int[] list = {17, 14, 9, 23, 18, 11, 62,
47, 33, 88};
// look for this value in the list
int searchFor = 33;
// Loop thru list until we find match
int foundAt = -1; // where found (default)
for (int index = 0; index < list.length; index++)
{
if (list[index] == searchFor) {
foundAt = index;
break;
// jump out of the loop
}
}
// foundAt is now index of item “searchFor”
// or -1 if not found
// Linear search of unordered list of Strings
// unordered list
String[] list = {“Bart”, “Homer”, “Marge”,
“Lisa”, “Maggie”, “Millhouse”};
// look for this value in the list
String searchFor = “Maggie”;
// Loop thru list until we find match
int foundAt = -1; // where found (default)
for (int index = 0; index < list.length; index++)
{
if (list[index].equals(searchFor)) {
foundAt = index;
break;
// jump out of the loop
}
}
// foundAt is now index of item ``searchFor’’
// or -1 if not found
Binary Search
• Requires ordered (sorted) list
• Set searchRange to the entire list
• Repeat:
– pick a “test value” in the middle of searchRange
– if test value == value searching for
• Stop!
– if test value > value searching for
• searchRange = lower half of searchRange
– if test value < value searching for
• searchRange = upper half of searchRange
Example
Looking for 46
Trial 1
2 4 5 12 16 19 22 26 29 32 37 41 46 50
2
2 4 5 12 16 19 22
26 29 32 37 41 46 50
3
2 4 5 12 16 19 22 26
29 32 37
41 46 50
Notes on Binary Searches
• List must be ordered (sorted)
– can maintain a list in ordered fashion
• Much more efficient than linear
– in example, took 3 iterations instead of 13
– time ~ log2(listLength)
– linear
• worst case ~ listLength
• average ~ listLength/2
– for 100K words: 17 iterations versus 50,000
• More complex to program
Searching
Things To Know
• Be able to recognize and write a linear
search
• Understand its pros and cons
• Know the concepts of a Binary Search
Questions
2 10 17 45 49 55 68 85 92 98
How many comparisons are needed to determine if
the following items are in the list of 10 items?
number
15
linear search
binary search
3 (49, 10, 17)
49
10 (3, if know
list sorted)
5
98
10
2
1
4 (49, 85, 92,
98)
3 (49, 10, 2)
1
Sorting
• Put elements of an array in some order
– alphabetize names
– order grades lowest to highest
• Two simple sorting algorithms
– selection sort
– insertion sort
Selection Sort
• Sorts by putting values directly into their
final, sorted position
• For each position in the list, the
selection sort finds the value that
belongs in that position and puts it there
Selection Sort
General Algorithm
• Scan the list to find the smallest value
• Exchange (swap) that value with the value in
the first position in the list
• Scan rest of list for the next smallest value
• Exchange that value with the value in the
second position in the list
• And so on, until you get to the end of the list
Selection Sort
At Work
98
68
83
74
93
68
98
83
74
93
68
74
83
98
93
68
74
83
98
93
68
74
83
93
98
SORTED!
Selection Sort
• Sorts in ascending order
• Can be changed to sort in descending
order
– look for max instead of min
Insertion Sort
• Like we’d actually sort things
• Insert each new item into an already
sorted list
• Each unsorted element is inserted at
the appropriate spot in the sorted
subset until the list is ordered
Insertion Sort
General Algorithm
• Sort the first two values (swap, if necessary)
• Repeat:
– insert list’s next value into the appropriate position
relative to the first ones (which are already sorted)
• Each time insertion made, number of values
in the sorted subset increases by one
• Other values in array shift to make room for
inserted elements
Insertion Sort
At Work
98
68
83
74
93
68
98
83
74
93
68
83
98
74
93
68
74
83
98
93
68
74
83
93
98
SORTED!
Insertion Sort
• Outer loop controls the index in the array of
the next value to be inserted
• Inner loop compares the current insert value
with values stored at lower indexes
• Each iteration of the outer loop adds one
more value to the sorted subset of the list,
until the entire list is sorted
Bubble Sort
• "bubble"
– largest values bubble to the end
– smallest values sink to the beginning
• Idea
– go through the list and swap neighboring items if
needed
• Pros
– easy to understand and code
• Cons
– horribly inefficient (listLength2)
Bubble Sort
At Work
98
68
83
74
93
68
98
83
74
93
68
83
98
74
93
68
83
74
98
93
68
83
74
93
98
68
74
83
93
98
SORTED!
Sort Implementations
• All three use double (nested) loops
• Selection and insertion
– an outer loops scans all elements
– an inner loop scans and switches/inserts as
needed
• Bubble
– an outer loop repeats until no swaps are needed
– an inner loops scans and swaps as needed
Sorting
Things To Know
• Be able to recognize and follow an
insertion sort, selection sort, and bubble
sort
• Understand their pros and cons
• Know that many other sorts exist with
varying efficiency and programming
difficulty
Sorting animations (in Java of course!)
http://www.cs.hope.edu/~alganim/animator/Animator.html
Question
Given the operation of the following sort,
identify the type of sort (selection,
insertion, or bubble)
34
21 97 15 87 original
21
21
21
21
15
34
34
34
15
21
97
15
15
34
34
15
97
87
87
87
87
87
97
97
97
pass 1
pass 2
pass 3
pass 4
pass 5
SORTED
Question
Given the operation of the following
sort, identify the type of sort
(selection, insertion, or bubble)
34
21
21
15
15
21
34
34
21
21
97
97
97
34
34
15
15
15
97
87
87
87
87
87
97
original
pass 1
pass 2
pass 3
pass 4
SORTED
Sorting
Things Other Than Numbers
• characters
– same as integers (compare with < and >)
• Strings
– use the built-in compareTo method
• Other Objects
– we write a compareTo method
– use the compareTo method