Except where otherwise noted, the contents of this document are Copyright 2012 Stuart Reges and Marty Stepp.
lab document created by Marty Stepp, Stuart Reges, Whitaker Brand and Hélène Martin
Goals for today:
for
loops to traverse and process array dataRandom
methods
To use these methods, you need a variable of type Random
in
scope:
Random randy = new Random();
int aRandomNumber = randy.nextInt(10); // 09
Method name  Returns... 

nextInt()

a random integer 
nextInt(max)

a random integer between 0 (inclusive) and max (exclusive) 
nextDouble()

a random real number between 0.0 and 1.0 
nextBoolean()

a random boolean value: true
or false

Fill in the boxes to produce expressions that will generate random numbers in the provided ranges.
Assume that the following Random
variable has been declared:
Random rand = new Random();
Example: a random integer from 1 to 5 inclusive: 
rand.nextInt(5)
+
1

a random integer from 0 to 3 inclusive: 
rand.nextInt(4)

a random integer from 5 to 10 inclusive: 
rand.nextInt(6)
+
5

a random integer from 4 to 4 inclusive: 
rand.nextInt(9)

4

a random even integer from 16 to 28 inclusive: (Hint: To get only even numbers, scale up.) 
rand.nextInt(7)
*
2
+
16

Write a method named makeGuesses
that will output random
numbers between 1 and 50 inclusive until it outputs one of at least 48.
Output each guess and the total number of guesses made. Below is a sample
execution:
guess = 43 guess = 47 guess = 45 guess = 27 guess = 49 total guesses = 5
Try solving this problem in PracticeIt! from the link above.
Write a method flip
that takes a Random
object as
a parameter and that prints information about a coinflipping simulation.
Your method should use the Random
object to produce a sequence
of simulated coin flips, printing whether each flip comes up "heads" or
"tails". Each outcome should be equally likely. Your method should stop
flipping when you see three heads in a row.
Solve this problem in PracticeIt by clicking on the checkmark above.
Which of the following choices is the correct syntax for declaring/initializing an array of integers?
Which of the following choices is the correct syntax for quickly declaring/initializing an array of integers to store a particular list of values? We didn't get to this in lecture  check the slides or chapter 7 in the book.
Fill in the array with the values that would be stored after the code executes:
int[] data = new int[8]; data[0] = 3; data[7] = 18; data[4] = 5; data[1] = data[0]; int x = data[4]; data[4] = 6; data[x] = data[0] * data[1];
index  0  1  2  3  4  5  6  7 

value  3  3  0  0  6  9  0  18 
Fill in the array with the values that would be stored after the code executes:
int[] list = {2, 18, 6, 4, 5, 1}; for (int i = 0; i < list.length; i++) { list[i] = list[i] + (list[i] / list[0]); }
index  0  1  2  3  4  5 

value  3  24  8  5  6  1 
3  28  53  78 
continued on the next slide...
System.out.print
inside the if
on line 23 and debug the program.
count
,
and drop it on the main code window. This will show a view of its contents. count
array?
index  0  1  2  3  4  5  6  7 

value  4  4  0  10  0  4  4  0 
continued on the next slide...
System.out.print
is about to execute, then stops.)
index  0  1  2  3  4  5  6  7 

value  8  8  0  20  0  8  8  0 
index  92  93  94  95  96  97  98  99 

value  0  0  0  8  8  0  0  0 
public static type name(type[] name) { // pass array parameter
public static type[] name(parameters) { // return array
double
s, and returns a new array of rounded int
s:
public static int[] roundAll(double[] realNums) { int[] roundedNums = new int[realNums.length]; for (int i = 0; i < realNums.length; i++) { roundedNums[i] = (int) Math.round(realNums[i]); } return roundedNums; }
roundAll
method from the previous slide:
import java.util.*; // to use Arrays
public class MyProgram {
public static void main(String[] args) {
double[] realNumbers = {5.5, 7.31, 8.09, 3.234234, 2.0, 0.0};
int[] roundedNumbers = roundAll(realNumbers);
System.out.println(Arrays.toString(roundedNumbers));
}
...
}
// Output: [5, 7, 8, 3, 2, 0]
Suppose that each array at right were passed as a parameter to
the mystery
method below. Fill in the boxes with the array
contents after each method call.
public static void mystery(int[] a) { for (int i = 0; i < a.length  1; i++) { if (a[i] < a[i + 1]) { a[i] = a[i + 1]; } } } 

1 2 3 4 5 6 7 8 9 10 
// Returns the largest value in the given array.
public static int max(int data[10]) {
int max = 0;
for (int i = 0; i < data[].length(); i++) {
if (array[i] > max) {
max = array[i];
}
}
return max[];
}

The above attempted solution to PracticeIt problem "max
" has
7 problems. Open PracticeIt from the link above, copy/paste this code
into it, and fix the errors. Complete the code so that it passes the test
cases.
[10]
after parameter name; should
write []
(without length) after int
max
at 0
won't work if the
array is all negative. Should initialize max
variable to
be data[0]
and start for
loop at
index 1
[]
after data
here
()
after length
here
array
should be data
array
should be data
[]
after max
here
1 2 3 4 5 6 7 8 9 10 
// Returns the largest value in the given array. public static int max(int[] data) { int max = data[0]; for (int i = 1; i < data.length; i++) { if (data[i] > max) { max = data[i]; } } return max; } 
PromptNumbers.java
program from a previous exercise.
public class PromptNumbers2 { public static void main(String[] args) { int count = console.nextInt(); int[] nums = new int[count]; ... System.out.println("Your numbers in forward order:"); printForward(nums); System.out.println("Your numbers in backward order:"); printBackward(nums); } // Prints the elements of the given array in forward order. public static void printForward(int[] a) { for (int i = 0; i < a.length; i++) { System.out.println(a[i]); } } // Prints the elements of the given array in backward order. public static void printBackward(int[] a) { for (int i = a.length  1; i >= 0; i) { System.out.println(a[i]); } } }
minGap
Write a method named minGap
that accepts an integer array as a
parameter and returns the minimum 'gap' between adjacent values in the
array. The gap between two adjacent values in a array is defined as the
second value minus the first value. For example, suppose a variable
called array
is an array of integers that stores the following
sequence of values:
int[] array = {1, 3, 6, 7, 12};
The first gap is 2 (3  1), the second gap is 3 (6  3), the third gap is 1
(7  6) and the fourth gap is 5 (12  7). Thus, the call
of minGap(array)
should return 1
because that is
the smallest gap in the array. If you are passed an array with fewer than
2 elements, you should return 0
.
Click on the checkmark above to try out your solution in Practiceit!
percentEven
Write a method named percentEven
that accepts an array of
integers as a parameter and returns the percentage of even numbers in the
array as a real number. For example, if a variable named nums
refers to an array of the elements {6, 2, 9, 11, 3}
, then the
call of percentEven(nums)
should return 40.0
. If
the array contains no even elements or no elements at all,
return 0.0
.
Click on the checkmark above to try out your solution in Practiceit!
stretch
Write a method named stretch
that accepts an array of integers as a parameter and returns a new array twice as large as the original, replacing every integer from the original array with a pair of integers,
each half the original.
If a number in the original array is odd, then the first number in the new pair should be one higher than the second so that the sum equals the original number.
For example, if a variable named list
refers to an array storing the values {18, 7, 4, 24, 11}
,
the call of stretch(list)
should return a new array containing {9, 9, 4, 3, 2, 2, 12, 12, 6, 5}
.
(The number 18 is stretched into the pair 9, 9, the number 7 is stretched into 4, 3, the number 4 is stretched into 2, 2, the number 24 is stretched into 12, 12 and the number 11 is stretched into 6, 5.)
Click on the checkmark above to try out your solution in Practiceit!
equals
Write a method named equals
that accepts two arrays of integers as parameters and returns true
if they contain exactly the same elements in the same order, and false
otherwise.
Note that the arrays might not be the same length; if the lengths differ, return false
. Do not call Arrays.equals
in your solution.
For example, if the following arrays are declared:
int[] a1 = {10, 20, 30, 40, 50, 60}; int[] a2 = {10, 20, 30, 40, 50, 60}; int[] a3 = {20, 3, 50, 10, 68};
The call equals(a1, a2)
returns true
but the call equals(a1, a3)
returns false
.
If you finish all the exercises, try out our PracticeIt web tool. It lets you solve Java problems from our Building Java Programs textbook.
You can view an exercise, type a solution, and submit it to see if you have solved it correctly.
Choose some problems from the book and try to solve them!