# University of Washington, CSE 142

## Lab 5: Random numbers, boolean logic, and midterm practice

Except where otherwise noted, the contents of this document are Copyright 2011 Stuart Reges and Marty Stepp.

lab document created by Marty Stepp, Stuart Reges, and Whitaker Brand

# Basic lab instructions

• We encourage you to talk to your classmates for help. You can even work on the lab with a partner if you like.
• You may want to bring your textbook to future labs to look up syntax and examples.
• Stuck? Confused? Have a question? Ask a TA for help, or look at the book or past lecture slides.
• You probably won't finish all of the exercises. Just do as much as you can within the allotted time. You don't need to keep working on these exercises after you leave the lab.
• Before you leave today, make sure to check in with one of the TAs in the lab to get credit for your work.

# Today's lab

Goals for today:

• use `Random` objects to produce random numbers
• use `boolean` expressions and variables to represent logical true/false expressions
• examine logical assertions that can be made about a running program
• practice problems similar to what will be on the midterm exam
• Where you see this icon, you can click it to check the problem in Practice-It!

# `Random` methods

To use these methods, you need a variable of type `Random` in scope:

```Random randy = new Random();
int aRandomNumber = randy.nextInt(10);  // 0-9
```
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`

# Exercise : Random expressions

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 ```

# The `boolean` type

The `boolean` type represents logical values of `true` or `false`. Combine `boolean` expressions with logical operators `&&` (and), `||` (or), and `!` (not).

Example:

```boolean test1 = 7 < 10;            // true
boolean test2 = (1 == 2);          // false
if ((test1 || test2) && 2 + 2 != 5) {
System.out.print("hello");     // output: hello
}
```

# `String` methods with `boolean` results

Method name Description
string`.equals(string)` whether the two strings are identical
string`.equalsIgnoreCase(string)` whether the two strings are identical, ignoring capitalization
string`.startsWith(string)` whether this string begins with the characters of the given string
string`.endsWith(string)` whether this string ends with the characters of the given string
string`.contains(string)` whether the characters of the given string occur within this string
```String name = "Professor Smith";
if (name.startsWith("Prof")) {
}
```

# Exercise : Boolean Expressions

Write the result of each expression as either `true` or `false`, given the following variables.

```int x = 12;
int y = 7;
int z = 28;
String s = "mid term";
```
 `x < 14` `true` `!(x % 2 < 1)` `false` `x < y || x < z` `true` `z / x < x / y * x` `true` `s.length() == y` `false` `s.toUpperCase().equals("MID TERM")` `true` `!s.equals("mid term") || x * y != z` `true` `s.substring(z / x).length() > y` `false`

# Exercise : assertions

Identify whether each assertion is always/never/sometimes `true` at each point.

`x > y` `z == 0` `x == y`
A
B
C
D
E
```public static void mystery(int x, int y) {
int z = 0;

// Point A
while (x != y) {
// Point B
z++;

if (x > y) {
// Point C
x = x / 10;
} else {
// Point D
y = y / 10;
}
}

// Point E
System.out.println(x + " " + y + " " + z);
}
```

You can also solve this problem in Practice-It by clicking on the check-mark above.

# Midterm exam review

The CSE 142 midterm exam is usually very similar to the format of the practice exams. The following kinds of problems are often found on the exam:

• expressions (given an expression, write the value it produces)
• parameter mystery (read code with parameters and write its output)
• if/else mystery (read code with if/else statements and write its output)
• while loop mystery (read code with while loops and write its output)
• assertions (given a piece of code, what can we say is always / sometimes / never true?)
• programming problems (write code to implement a method with specific behavior)

To solve each problem, you will need to use various concepts and syntax taught throughout the course so far, such as System.out.println, expressions, variables, parameters, return, if/else, for/while loops, Scanner, and Random. Part of the challenge is in figuring out which tools to use and how to use them together to solve the problem at hand.

# Exercise : lastDigit

• Write a method named `lastDigit` that returns the last digit of an integer. For example, `lastDigit(3572)` should return `2`. It should work for negative numbers as well. For example, `lastDigit(-947)` should return `7`.
• Try solving this problem in Practice-It! using the link above.
• (Hint: This is a short method.)

# Exercise : firstDigit

• Write a method named `firstDigit` that returns the first digit of an integer. For example, `firstDigit(3572)` should return `3`. It should work for negative numbers as well. For example, `firstDigit(-947)` should return `9`.
• Try solving this problem in Practice-It! using the link above.
• (Hint: This problem requires a loop.)

# Exercise : season

• Write a method named `season` that takes two integers as parameters representing a month and day and that returns a String indicating the season for that month and day. Assume that months are specified as an integer between 1 and 12 (1 for January, 2 for February, and so on) and that the day of the month is a number between 1 and 31.
• If the date falls between 12/16 and 3/15, you should return `"Winter"`. If the date falls between 3/16 and 6/15, you should return `"Spring"`. If the date falls between 6/16 and 9/15, you should return `"Summer"`. And if the date falls between 9/16 and 12/15, you should return `"Fall"`.
• Try solving this problem in Practice-It! using the link above.

# Exercise : makeGuesses

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 Practice-It! from the link above.

# Exercise : allDigitsOdd

Write a method named `allDigitsOdd` that returns whether every digit of a positive integer is odd. Your method should return `true` if the number consists entirely of odd digits and `false` if any of its digits are even. 0, 2, 4, 6, and 8 are even digits, and 1, 3, 5, 7, 9 are odd digits.

For example, `allDigitsOdd(135319)` returns `true` but `allDigitsOdd(9145293)` returns `false`.

Hint: You can pull apart a number into its digits using ```/ 10``` and `% 10`.

# Exercise : hopscotch

Write a method named `hopscotch` that accepts an integer parameter for a number of "hops" and prints a hopscotch board of that many hops.

For example, the call `hopscotch(3);` would produce the following output:

```   1
2     3
4
5     6
7
8     9
10
```

Try to solve this problem in Practice-It: click on the check-mark above!

# Exercise : hasMidpoint

Write a method `hasMidpoint` that accepts three integers as parameters, and returns `true` if one of the numbers is the midpoint of the other two and returns `false` otherwise.

For example, the call `hasMidpoint(3, 7, 5)` would return `true` because one of the parameters (5) is the midpoint of the other two (3 and 7).

Try to solve this problem in Practice-It: click on the check-mark above!

# Exercise : Syntax errors

• The following Java program has 11 errors. Can you find them all?  ``` 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 ``` ```public class StringOops { public static void main(String[] args) { Scanner console = new Scanner(System.in); System.out.print("Type your name: "); String name = console.nextString(); process(name); } public static void process(string "name") { if (name == Whitaker) { System.out.println("You must be really awesome."); } replace("a", "e"); toUppercase(name); name.substring(0, 3); System.out.println(name + " has " + name.length + " letters"); } } ```
• Copy and paste the code into jGrasp and see if you can fix the errors.

1. line 5: `nextString` should be `next`
2. line 9: `string` should be `String`
3. line 9: `name` should not be in quotes
4. line 10: `Whitaker` should be in quotes
5. line 10: cannot compare strings with `==`; must use `.equals`
6. line 13: cannot call `replace` without specifying a string object (`name`)
7. line 14: `toUppercase` should be `toUpperCase`
8. line 14: `name.` should come before `toUpperCase`, not passed as a parameter to it
9. line 14: must say `name =` to store the result of `toUpperCase`
10. line 15: must say `name =` to store the result of `substring`
11. line 16: must use parentheses `()` when calling `length`

# Exercise - Corrected version

```public class StringOops {
public static void main(String[] args) {
Scanner console = new Scanner(System.in);
String name = console.next();
process(name);
}

public static void process(String "name") {
if (name.equals("Whitaker")) {
System.out.println("You must be really awesome.");
}
name = name.replace("a", "e");
name = name.toUpperCase();
name = name.substring(0, 3);
System.out.println(name + " has " + name.length() + " letters");
}
}
```

# Exercise : ZuneBug

The following code from Microsoft's Zune music player calculates today's date from the years/days passed since 1980. But all Zune players locked up on Dec 31 2008. Why? Download ZuneBug.java and modify it to fix the bug.

```int days = getTotalDaysSince1980();   // pretend this method exists
int year = 1980;
while (days > 365) {                  // subtract out years
if (isLeapYear(year)) {           // pretend this method exists
if (days > 366) {
days = days - 366;
year++;
}
} else {
days = days - 365;
year++;
}
}
```

# Exercise : ZuneBug - answer

The bug occurs when the current year is a leap year and there are exactly 366 days left (i.e., if today is Jan 1 on a year after a leap year). The code gets stuck in an infinite loop with `days == 366` because the `while` test is `true` but the ```if (days > 366)``` is `false`. Here is a fixed version:

```int days = getTotalDaysSince1980();   // pretend this method exists
int year = 1980;
while (days > 365 || (isLeapYear(year) && days > 366)) {
if (isLeapYear(year)) {
days = days - 366;
} else {
days = days - 365;
}
year++;
}
```

# Exercise : before

Write a method `before` that takes as parameters two month/day combinations and that returns whether or not the first date comes before the second date (`true` if the first month/day comes before the second month/day, `false` if it does not). The method will take four integers as parameters that represent the two month/day combinations.

The first integer in each pair represents the month and will be a value between 1 and 12 (1 for January, 2 for February, etc, up to 12 for December). The second integer in each pair represents the day of the month (a value between 1 and 31). One date is considered to come before another if it comes earlier in the year.

Solve this problem in Practice-It by clicking on the check-mark above.

# Exercise : sameDashes

Write a method `sameDashes` that takes two strings as parameters and that returns whether or not they have dashes in the same places (returning `true` if they do and returning `false` otherwise). For example, below are four pairs of strings of equal length that have the same pattern of dashes. Notice that the last pair has no dashes at all.

```string 1:    "hi--there-you."    "-15-389"    "criminal-plan"    "abc"
string 2:    "12--(134)-7539"    "-xy-zzy"    "(206)555-1384"    "9.8"
```
To be considered a match, the strings must have exactly the same number of dashes in exactly the same positions. The Strings might be of different length.

Solve this problem in Practice-It by clicking on the check-mark above.

# Exercise : flip

Write a method `flip` that takes a `Random` object as a parameter and that prints information about a coin-flipping 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 Practice-It by clicking on the check-mark above.

# Exercise : "Boolean Zen"

This attempted solution to Self-Check 5.15 (`isVowel`) has several problems:

```// Returns whether the given string represents a vowel:
// a, e, i, o, or u, case insensitively.
public static boolean isVowel(String s) {
if (s == "a") {
return true;
} else if (s == "e") {
return true;
} else if (s == "i") {
return true;
} else if (s == "o") {
return true;
} else if (s == "u") {
return true;
} else {
return false;
}
}
```

Open Practice-It from the link above, copy/paste this code into it, then see the next slide.

# Exercise - things to fix

Fix the following aspects of the code:

• It has a bug related to how strings are compared.
• It isn't case sensitive; it fails for uppercase vowels.
• It has too many unnecessary if/else statements.
• (advanced) It does not use "Boolean Zen" as described in textbook section 5.3.

```public static boolean isVowel(String s) {
s = s.toLowerCase();
if (s.equals("a") || s.equals("e") || s.equals("i")
|| s.equals("o") || s.equals("u")) {
return true;
} else {
return false;
}
}
```

The above can be improved. "Boolean Zen" version:

```public static boolean isVowel(String s) {
s = s.toLowerCase();
return s.equals("a") || s.equals("e") || s.equals("i")
|| s.equals("o") || s.equals("u");
}
```

# If you finish them all...

If you finish all the exercises, try out our Practice-It 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!