CS 152 - Lecture 3

Cay S. Horstmann

Blocks

• In Scala, a block is an expression with a value.

  val distance = {
    val dx = x2 - x1
    val dy = y2 - y1
    math.sqrt(dx * dx + dy * dy)
  }
  

• The last expression in the block is the value of the block.
• Common in complex recursions.

  def digitsum(n: Int): Int = if (n == 0) 0 else {
    val last = n % 10
    val rest = n / 10
    last + digitsum(rest)
  }
  

Local Functions

• You can define a function inside another function:

  def distance(x1: Int, x2: Int, y1: Int, y2: Int) = {
    def sq(x: Int) = x * x
    math.sqrt(sq(x2 - x1) + sq(y2 - y1))
  }
  

• Useful for recursive helper functions.

  def digitsum(n: Int) = {
    @tailrec def digitsumHelper(n: Int, sum: Int): Int = if (n == 0) sum else
      digitsumHelper(n / 10, sum + n % 10)
    digitsumHelper(n, 0)
  }
  

• @tailrec tells Scala that you believe that the recursion can be rewritten as a loop.

  def digitsumHelper(n: Int, sum: Int): Int = {
    start:
      if (n == 0) sum else {
        n = n / 10
        sum = sum + n % 10
        goto start
      }
  }
  

Lists

• Very different from Java linked lists. No iterators
• Three primitives: head, tail, :: (pronounced cons)
• A list is either empty (Nil) or has a head and tail

  val lst = List(1, 4, 9)
  lst.head // 1
  lst.tail // List(4, 9)
  lst.tail.tail.tail // Nil

• Use :: to build lists

  0 :: lst // List(0, 1, 4, 9)

List Functions

• Use recursion for list functions

  def sum(lst : List[Int]) : Int = 
    if (lst.isEmpty) 
      0 else 
      lst.head + sum(lst.tail)

• Use :: to recursively build lists

  def squares(n : Int) : List[Int] = 
    if (n == 0) 
      List(0) else
      n * n :: squares(n - 1)

Why This Isn't Inefficient

• lst.tail doesn't make a new list—it is a reference to the tail cell

  

• Works because lists are immutable

More Recursion Examples

• def append(a: List[Int], b: List[Int]): List[Int] = if (a.isEmpty) b else
    a.head :: append(a.tail, b)
  

• def reverse(a: List[Int]): List[Int] = if (a.isEmpty) a else
    append(reverse(a.tail), List(a.head))
  

• reverse((1 to 1000000).toList)
  (1 to 1000000).toList.reverse
  

• def reverse(a: List[Int]) = {
    @tailrec def reverseHelper(a: List[Int], reversed: List[Int]): List[Int] =
      if (a.isEmpty) reversed else reverseHelper(a.tail, a.head :: reversed)
    reverseHelper(a, Nil)
  }
  

Lab

• You work with a buddy
• One of you writes the code (coder), the other types up answers (scribe)
• When you get stuck, ask your buddy first!
• Switch roles each lab. The previous scribe is the coder for this lab.
• The scribe submits lab work in lab2/report.txt inside the Git repo. Include the coder's name in the report!
• If the coder wants to submit something, that's cool too. Do whatever is easy.

Step 1: Lists

1. What is the type of 1 :: 2 :: 3 :: Nil? (Just ask the Scala interpreter)
2. What is the type of 1 :: "Hello" :: Nil?
3. What happens when you evaluate the expression 1 :: 2 :: 3? Why?
4. How do you make a list of the elements "San", "José", "State", "University" using a list constructor? (Be sure to try your answer in the Scala interpreter)
5. How do you make a list of the elements "San", "José", "State", "University" using the cons (::) operator?

Step 2: List Functions

1. Write a recursive function concat that concatenates all strings in a List[String], yielding a String. Hint: (1) String concatenation is + in Scala, just like in Java (2) concat(Nil) is "". (3) Think about concat(lst) in terms of lst.head, lst.tail.

   Give the code of your function.

2. What is the result of concat(List("San", "José", "State", "University"))?
3. How can you modify concat so that it adds spaces between the strings (i.e. so that concat(List("San", "José", "State", "University")) is "San José State University" but not "San José State University " or " San José State University"?

Step 3: More Recursion

1. Given a list, form a list of all pairs of elements (as lists of length 2) in some order. If the original list has length n, form n² pairs. What should pairs(List(1, 2, 3)) produce?
2. What is your strategy for recursion? Base case? Reduction to simpler case?
3. What is your Scala code?

Step 4: Not Always Recursion

1. How can you implement the squares function from the lecture without recursion?
2. The flatten method flattens out a list of lists into a list. To see what it does, just try out

   List(List(1, 2),List(3, 4, 5)).flatten

   Assuming that you are allowed to use this method, how can you implement the pairs function of Step 3 without recursion?