University of Washington, CSE 142

Lab 5: While Loops, Random, Boolean and 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

• 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.
• Complete as many problems as you can within the allotted time. You don't need to keep working on these exercises after you leave the lab.
• Feel free to complete problems in any order.
• 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:

• practice cumulative algorithms for complex computations
• use while loops for indefinite repetition
• practuce the fencepost and sentinel loops patterns
• 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!

Cumulative algorithms

• A cumulative algorithm is one where you incrementally accumulate a larger value by repeatedly adding, multiplying, etc., and storing the result into a variable over and over.
• Key aspect of a cumulative algorithm: A loop, and a variable declared outside the loop whose value is modified inside the loop.
• Example: Cumulative algorithm to sum the numbers 1-100:

  int sum = 0;
  for (int i = 1; i <= 100; i++) {
      sum = sum + i;
  }
  System.out.println(sum);    // 5050
  

• Some of the following problems ask you to write cumulative algorithms.

Exercise : repl

• Write a method named repl that accepts a String and a number of repetitions as parameters and returns the String concatenated that many times. For example, the call repl("hello", 3) returns "hellohellohello". If the number of repetitions is 0 or less, an empty string is returned.
• Try solving this problem in Practice-It! using the link above.
• (Hint: This is best solved with a cumulative algorithm. Start with an empty string and build it up piece by piece.)

Exercise : longestName

Write a method named longestName that reads names typed by the user and prints the longest name (the name that contains the most characters) in the format shown below. Your method should accept a console Scanner and an integer n as parameters and should then prompt for n names.

A sample execution of the call longestName(console, 4) might look like the following:

name #1? roy
name #2? DANE
name #3? sTeFaNiE
name #4? Erik
Stefanie's name is longest

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

Fencepost Loops

A fencepost loop is a common algorithmic pattern where you want to perform N tasks with N-1 things between them. It's like a fence with N posts with N-1 wires between the posts.

To achieve this, place one "post" outside your loop, then alternate between "wires" and "posts" inside the loop.

Example:

System.out.print(1);                 // |==|==|==|==| fence
for (int i = 2; i <= 5; i++) {
    System.out.print(".." + i);      // 1..2..3..4..5
}

Exercise : printFactors

• Write a method called printFactors that accepts an integer as its parameter and that prints the factors of that number, separated by the word "and". Recall that a factor is a number that goes evenly into another number. For example, the call printFactors(24) should print the following output:

  1 and 2 and 3 and 4 and 6 and 8 and 12 and 24
  

• You may assume that the parameter value passed is greater than 0.
• Try solving this problem in Practice-It! using the link above.

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

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();

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

String name = "Professor Smith";
if (name.startsWith("Prof")) {
    System.out.println("When are your office hours?");
}

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";

true

false

true

true

false

true

true

false

while Loops

A while loop repeats indefinitely until a given condition is met.

while (test) {
    statement(s);
}

Example:

int num = 1;
while (num < 5) {
    System.out.print(n + " ");     // output: 1 2 3 4
    n++;
}

Exercise : while loop basics

Consider the following loop.

int x = 1;
System.out.print(x);
while (x < 100) {
    x = x + x;
    System.out.print(", " + x);
}

Exercise : while loop mystery

Fill in the boxes at right with the output produced by each method call.

public static void mystery(int x) {
    int y = 1;
    int z = 0;
    while (2 * y <= x) {
        y = y * 2;
        z++;
    }
    System.out.println(y + " " + z);
}

1 0

4 2

16 4

32 5

64 6

Exercise : assertions

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

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 will be similar to the format of the practice exams. The exam will be made up of the following kinds of problems:

• 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 : 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).

9

10

"10+212"

9.1

2.0

Exercise : Parameter Mystery

• Fill in the boxes with the output that each method call would produce:

  public class Mystery {
      public static void main(String[] args) {
          String hear = "bad";
          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

Consider the following Java code.

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);
}

Fill in the boxes with the output produced by each of the method calls.

0 3

6 7

-4 4

8 21

Exercise : while loop mystery

Fill in the boxes at right with the output produced by each method call.

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);
}

1 2

1 5

4 3

3 7

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 : 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 : 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 : 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 : 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 : 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"

Solve this problem in Practice-It by clicking 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!