Techniques

• Sometimes one solution is better than the others
• Sometimes different solutions are appropriate in different settings
• We've already seen a couple of techniques:
  • Taking the (weighted) average of 2, 3, … numbers
  • Testing for even/odd, and divisibility in general
  • Repeating a body of code n times

Toggling a Boolean value

• To toggle a boolean means to change it from true to false and vice versa:

  boolean b;
  …
  // b is assigned a value (true or false)
  …
  b = !b;		// toggles b
  		

  for example:

  boolean isOn = true;
  …
  isOn = !isOn;
  		

• toggling is used for boolean values only

'First-time' Logic

• Particular application of a toggle
• Useful when a process is to be repeated (i.e., a loop of sorts) and something must be done the very first time only
• Essential idea is to have a boolean — let's call it isFirst — initialized to true which is toggled to false after the first iteration.

  boolean isFirst = true;
  for (.......) {
  	if (isFirst) {
  		… 			// do whatever needs doing the first time only
  		isFirst = false;	// makes sure we never do this again
  	}
  	…
  		

The positive numbers are:
…
…

import java.io.*;
import java.util.*;

public class PrintPositives {
	public static void main(String [] args) throws Exception {
		Scanner scanner = new Scanner(new File("numbers.text"));

		boolean isFirst = true;

		int n = scanner.nextInt();

		for (int i = 1; i <= n; i++) {
			int num = scanner.nextInt();
			if (num > 0) {
				if (isFirst) {
					System.out.println("The positive numbers are: ");
					isFirst = false;
				}
				System.out.println(num);
			}
		}
	}
}

'Not-First-time' Logic

• Equally useful is NOT doing something the first time
  • For example, print several numbers with commas between them
    • Can't always print a comma (and space) before printing the number, e.g., , 1, 2, 3
    • Can't always print a comma (and space) after printing the number, e.g., 1, 2, 3,
    • Either
      • print a comma before every number EXCEPT the first, or, (this is the one we'll use for now)
      • print a comma after every number EXCEPT the last

  boolean isFirst = true;
  for (.......) {
  	if (isFirst)
  		isFirst = false;	// don't want to do anything first time, but we have to toggle isFirst
  	else {
  		… 			// all the other times, do what needs to be done
  	}
  	
  	…
  		

import java.util.*;

public class CommaLogic {
        public static void main(String [] args) throws Exception {
                Scanner keyboard = new Scanner(System.in);

                System.out.println("Print from 1 to wwhere? ");
                int n = keyboard.nextInt();

                boolean isFirst = true;

                for (int i = 1; i <= n; i++) {
                        if (isFirst) 
                                isFirst = false;
                        else
                                System.out.print(", ");
                        System.out.print(i);
                }
        }
}

Swapping / Exchanging

• To swap two variables means to assign the value of the first to the second and vice versa
• Swapping requires a third variable, we usually refer to it as the temporary) and vice versa:

  int x, y;
  // x and y are assigned values
  
  int temp = x;
  x = y;
  y = temp;
  		

• Swapping works for any pair of variables of the same type
  • and the temp should be declared to be of the same type as well

Sorting

• Arranging a sequence of values (e.g. integers) so they are in either ascending or descending order
• We're just going to scratch the surface here

Rotation / Shifting

• Essentially a swap among more than two values
  • Values are moved from one variable to the next

    1 2 3 → 3 1 2		// Each variable's value move to the variable to its right; least one comes around 
    				

    • Note that the order of variables moved is crucial
  • Right vs left
• Rotation involves bringing element falling off end to other end

  1 2 3 → 3 1 2		// right rotation
  1 2 3 → 2 3 1		// left rotation
  		

• Shifting loses the element falling off and inserts some 'standard' value (often 0 or 1 if integers) at other end

  1 2 3 → 0 1 2		// right shift with 0 fill
  1 2 3 → 2 3 0		// left shift with 0 fill
  		

Maximum (Minimum)

Brute Force

public class BruteForceMax {
	public static void main(String [] args) {
		System.out.println(max(2, 3, 1));
	}

	public static int max(int x, int y, int z) {
		int max;
		if (x >= y && x >= z) 
			max = x;
		else if (y >= x && y >= z) 
			max = y;
		else 
			max = z;
		return max;
	}
}

• Explodes in size

'Semi brute' force

public class SemiBruteForceMax {
	public static void main(String [] args) {
		System.out.println(max(2, 3, 1));
	}

	public static int max(int x, int y, int z) {
		int max;
		if (x > y)
			if (x > z)
				max = x;
			else
				max = z;
		else
			if (y > z)
				max = y;
			else
				max = z;
		return max;
	}
}

• Breaks the problem up somewhat
• Still explodes in size
• Also forms a complex set of nested if's

Cascaded

public class CascadedMax {
	public static void main(String [] args) {
		System.out.println(max(2, 3, 1));
	}

	public static int max(int x, int y, int z) {
		int max = x;
		if (y > max) max = y;
		if (z > max) max = z;
		return max;
	}
}

• n variables → n-1 conditionals
• we'll see this is a standard way of taking a maximum

Method Composition

public class CompositionMax {
	public static void main(String [] args) {
		System.out.println(max(2, 3, 1));
	}

	public static int max(int x, int y, int z) {
		return max(max(x, y), z);
	}

	public static int max(int x, int y) {
		if (x > y) return x;
		return y;
	}
}

• Notice the overloading of the methid name max: there is a 2-arg method and a 3-arg method
• The 3-arg uses the 2-arg method by calling it on two values, and then calling it again with the result of the first call and the third value
• Methods using method results as their arguments is a technique known as composition

Files used in this Lecture

Lab for Lecture 7