CS 46B - Lecture 7

Pre-class reading

• Sections 13.1 - 13.2, How To 13.1, Worked Example 13.1

Homework Tips

• Character classification.
• Helper functions .

Triangle Numbers

• Compute the area of a triangle of width n
• Assume each [] square has an area of 1
• Also called the n^thtriangle number
• The third triangle number is 6

  []
  [][]
  [][][]

Outline of Triangle Class

public class Triangle 
{ 
   private int width;  
   public Triangle(int aWidth) 
   { 
      width = aWidth; 
   } 
   public int getArea() 
   { 
      . . . 
   } 
}

Handling Triangle of Width 1

• The triangle consists of a single square
• Its area is 1
• Add the code to getArea method for width 1:

  public int getArea() 
  { 
     if (width == 1) { return 1; } 
     . . . 
  }

Handling the General Case

• Assume we know the area of the smaller, colored triangle

  []
  [][]
  [][][]
  [][][][]

• Area of larger triangle can be calculated as:
  smallerArea + width
• To get the area of the smaller triangle, make a smaller triangle and ask it for its area:

• Triangle smallerTriangle = new Triangle(width - 1);
  int smallerArea = smallerTriangle.getArea();

Completed getArea Method

public int getArea() 
{ 
   if (width == 1) { return 1; } 
   Triangle smallerTriangle = new Triangle(width - 1); 
   int smallerArea = smallerTriangle.getArea(); 
   return smallerArea + width; 
}

Computing the area of a triangle with width 4

• getArea method makes a smaller triangle of width 3
• It calls getArea on that triangle
  • That method makes a smaller triangle of width 2
  • It calls getArea on that triangle
    • That method makes a smaller triangle of width 1
    • It calls getArea on that triangle
      • That method returns 1
    • The method returns smallerArea + width = 1 + 2 = 3
  • The method returns smallerArea + width = 3 + 3 = 6
• The method returns smallerArea + width = 6 + 4 = 10
• The secret to success in recursion: Don't think about this

Recursion

• A recursive computation solves a problem by using the solution of the same problem with simpler values
• For recursion to terminate, there must be special cases for the simplest inputs
• To complete our Triangle example, we must handle width <= 0:

  if (width <= 0)  return 0;

• Two key requirements for recursion success:
  • Every recursive call must simplify the computation in some way
  • There must be special cases to handle the simplest computations directly

Other Ways to Compute Triangle Numbers

• The area of a triangle equals the sum:

  1 + 2 + 3 + . . . + width

• Using a simple loop:

  double area = 0;
  for (int i = 1; i <= width; i++)
     area = area + i;

• Using math:

  1 + 2 + . . . + n = n × (n + 1)/2
  => area = width * (width + 1) / 2

Lecture 7 Clicker Question 1

public class MysteryShape
{
   private int size;
   public MysteryShape(int size) { this.size = size; }
   public int getArea()
   {
      if (size == 1) return 1;
      MysteryShape smallerShape = new MysteryShape(size / 2);
      int area = 4 * smallerShape.getArea();
      if (size % 2 == 1) area += 2 * size - 1;
      return area;
   }
}

What is new MysteryShape(4).getArea()?

1. 1
2. 4
3. 16
4. Something else

Lecture 7 Clicker Question 2

What does this recursive method return?

public static int mystery(int n)
{
   if (n % 2 == 0) // it's even
      return mystery(n / 2);
   else if (n > 1)
      return mystery(3 * n + 1);
   else
      return 1;
}

1. It always returns 1
2. It either returns 1 or fails to return
3. It can return any integer value
4. It never returns any value

Lecture 7 Clicker Question 3

It is conjectured that the function from the preceding slide always returns, but nobody knows for sure. Some values take quite a few recursive calls:

27, 82, 41, 124, 62, 31, 94, 47, 142, 71, 214, 107, 322, 161, 484, 242, 121, 364, 182, 91, 274, 137, 412, 206, 103, 310, 155, 466, 233, 700, 350, 175, 526, 263, 790, 395, 1186, 593, 1780, 890, 445, 1336, 668, 334, 167, 502, 251, 754, 377, 1132, 566, 283, 850, 425, 1276, 638, 319, 958, 479, 1438, 719, 2158, 1079, 3238, 1619, 4858, 2429, 7288, 3644, 1822, 911, 2734, 1367, 4102, 2051, 6154, 3077, 9232, 4616, 2308, 1154, 577, 1732, 866, 433, 1300, 650, 325, 976, 488, 244, 122, 61, 184, 92, 46, 23, 70, 35, 106, 53, 160, 80, 40, 20, 10, 5, 16, 8, 4, 2, 1

Complete this program to return the number of steps until you reach 1. (Each step is either dividing by two, or multiplying by 3 and adding 1.)

What is the result of calling steps(63728127)?

1. 949
2. 950
3. 1132
4. Something else

Thinking Recursively

• Problem: test whether a sentence is a palindrome
• Palindrome: a string that is equal to itself when you reverse all characters
  • A man, a plan, a canal – Panama!
  • Go hang a salami, I'm a lasagna hog
  • Madam, I'm Adam

Implement isPalindrome Method

public class Sentence 
{ 
   private String text; 
   /** 
      Constructs a sentence. 
      @param aText a string containing all characters of the sentence 
   */ 
   public Sentence(String aText) 
   { 
       text = aText; 
   } 
   /** 
      Tests whether this sentence is a palindrome. 
      @return true if this sentence is a palindrome, false otherwise 
   */ 
   public boolean isPalindrome() 
   { 
      . . . 
   } 
}

Thinking Recursively: Step-by-Step

• Remove the first character
• Remove the last character
• Remove both the first and last characters
• Remove a character from the middle
• Cut the string into two halves

Thinking Recursively: Step-by-Step

• Most promising simplification: Remove first and last characters
  adam, I'm Ada, is a palindrome too!
• Thus, a word is a palindrome if
  • The first and last letters match, and
  • Word obtained by removing the first and last letters is a palindrome
  • What if first or last character is not a letter? Ignore it

Thinking Recursively: Step-by-Step

• Strings with two characters
  • No special case required; step two still applies
• Strings with a single character
  • They are palindromes
• The empty string
  • It is a palindrome

Thinking Recursively: Step-by-Step

public boolean isPalindrome() 
{ 
   int length = text.length(); 
   // Separate case for shortest strings. 
   if (length <= 1) { return true; } 
   // Get first and last characters, converted to lowercase. 
   char first = Character.toLowerCase(text.charAt(0)); 
   char last = Character.toLowerCase(text.charAt(length - 1)); 
   if (Character.isLetter(first) && Character.isLetter(last)) 
   { 
      // Both are letters. 
      if (first == last) 
      { 
         // Remove both first and last character. 
         Sentence shorter = new Sentence(text.substring(1, length - 1)); 
         return shorter.isPalindrome(); 
      } 
      else 
      { 
         return false;
      } 
   } 
   else if (!Character.isLetter(last)) 
   { 
      // Remove last character. 
      Sentence shorter = new Sentence(text.substring(0, length - 1)); 
      return shorter.isPalindrome(); 
   } 
   else 
   { 
      // Remove first character. 
      Sentence shorter = new Sentence(text.substring(1)); 
      return shorter.isPalindrome(); 
   } 
}

Lecture 7 Clicker Question 2

Suppose we changed

if (length <= 1) { return true; } 

to

if (length <= 0) { return true; } 

What would be the effect of this change?

1. The method would work continue to work correctly for all inputs
2. The method would give the wrong answer for all inputs
3. The method would throw an exception for some inputs
4. The method would fall into an infinite recursion for some inputs

Recursive Helper Methods

• Sometimes it is easier to find a recursive solution if you make a slight change to the original problem
• Consider the palindrome test of the previous slide
  It is a bit inefficient to construct new Sentence objects in every step
• Rather than testing whether the sentence is a palindrome, check whether a substring is a palindrome:

  /**
     Tests whether a substring of the sentence is a palindrome. 
     @param start the index of the first character of the substring
     @param end the index of the last character of the substring
     @return true if the substring is a palindrome
  */
  public boolean isPalindrome(int start, int end)

Recursive Helper Methods

• Then, simply call the helper method with positions that test the entire string:

  public boolean isPalindrome()
  {
     return isPalindrome(0, text.length() - 1);
  }

Recursive Helper Methods: isPalindrome

public boolean isPalindrome(int start, int end)
{
   // Separate case for substrings of length 0 and 1.
   if (start >= end) { return true; }
   // Get first and last characters, converted to lowercase. 
   char first = Character.toLowerCase(text.charAt(start)); 
   char last = Character.toLowerCase(text.charAt(end)); 
   if (Character.isLetter(first) && Character.isLetter(last)) 
   { 
      if (first == last) 
      { 
         // Test substring that doesn't contain the matching letters. 
         return isPalindrome(start + 1, end - 1); 
      } 
      else 
      { 
         return false; 
      } 
   } 
   else if (!Character.isLetter(last)) 
   { 
      // Test substring that doesn't contain the last character. 
      return isPalindrome(start, end - 1); 
   } 
   else 
   { 
      // Test substring that doesn't contain the first character. 
      return isPalindrome(start + 1, end); 
   } 
}

Lecture 7 Clicker Question 3

Consider this recursive function:

public static int mystery(int[] values, int start, int value)
{
   if (start == values.length) return value; 
   else return mystery(values, start + 1, Math.max(value, values[start]));
}

What does mystery(new int[] { 3, 1, 4 }, 0, Integer.MIN_VALUE ) return?

1. 3
2. 1
3. 4
4. Integer.MIN_VALUE