# University of Washington, CSE 142

## Lab 5-5: midterm practice

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

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

# Basic lab instructions

• Mouse over if you're not sure what they mean!
• Talk to your classmates for help.
• 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.
• Complete as much of the lab as you can within the allotted time. You don't need to keep working on these exercises after you leave.
• Feel free to complete problems in any order.
• Make sure you've signed in on the sign-in sheet before you leave!

# Today's lab

Goals for today:

• 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!

# 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

Write always/never/sometimes `true` at each point. If unsure how to, check out the assertions tutorial!

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

# Exercise : Expressions

For each expression in the left-hand column, indicate its value in the right-hand column. Be sure to list a constant of appropriate type (e.g., 7.0 rather than 7 for a double, Strings in quotes).

If you've forgotten how to tackle expressions problems, check out lab 2 for a recap!

 `12/5 + 8/4` `4` `2.5 * 2 + 17/4` `9.0` `41 % 15 % 7 + 17 % 3` `6` `21/2 + "7 % 3" + 17 % 4` `"107 % 31"` `46/3/2.0/3 * 4/5` `2.0`

# Exercise : Parameter Mystery

(Review this type of problem in lab 3!) Fill in the boxes with the output that each method call produces:

```public static void main(String[] args) {
String song = "good";
String good = "hear";
String walk = "talk";
String talk = "feel";
String feel = "walk";
claim(feel, song, feel);       // to walk the walk is good
claim(good, hear, song);       // to hear the good is bad
claim(talk, "song", feel);     // to feel the walk is song
claim("claim", talk, walk);    // to claim the talk is feel
}
public static void claim(String hear, String good, String song) {
System.out.println("to " + hear + " the " + song + " is " + good);
}
```

# Exercise : `if`/`else` mystery

```public static void ifElseMystery(int a, int b) {
if (a < b) {
a = a * 2;
}
if (a > b) {
a = a - 10;
} else {
b++;
}
System.out.println(a + " " + b);
}
```
(Review this type of problem in lab 4!) Fill in the boxes with the output produced by each of the method calls.
 `ifElseMystery(10, 3);` `0 3` `ifElseMystery(6, 6);` `6 7` `ifElseMystery(3, 4);` `-4 4` `ifElseMystery(4, 20);` `8 21`

# Exercise : `while` loop mystery

Fill in the boxes at right with the output produced by each method call. (Review how to do this type of problem in lab 5!)

```public static void mystery4(int n) {
int x = 1;
int y = 2;
while (y < n) {
if (n % y == 0) {
n = n / y;
x++;
} else {
y++;
}
}
System.out.println(x + " " + n);
}
```
 `mystery4(2);` `1 2` `mystery4(5);` `1 5` `mystery4(24);` `4 3` `mystery4(28);` `3 7`

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

If you're not sure how make/use a Random, review them here.

# Exercise : printMultiples

Write a static method called `printMultiples` that takes an integer `n` and an integer `m` as parameters and that prints a complete line of output reporting the first `m` multiples of `n`. For example, the following calls:

```printMultiples(3, 5);
printMultiples(7, 3);
```
should produce this output:
```The first 5 multiples of 3 are 3, 6, 9, 12, 15
The first 3 multiples of 7 are 7, 14, 21
```

Notice that the multiples are separated by commas. You are to exactly reproduce this format. Also notice the order of the parameters: the first parameter is the base number and the second parameter is the number of multiples to generate.

You may assume that the number of multiples you will be asked to generate is greater than or equal to one.

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

# 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`. (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 : 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 : 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 : 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!

# 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!