In Ruby On Rails By Leigh Halliday May 26, 2015 Leigh Halliday

Recursion in Ruby

This article is the counterpart to one I wrote on Recursion in Elixir.

What is recursion?

Recursion in computer science is a method where the solution to a problem depends on solutions to smaller instances of the same problem (as opposed to iteration).
Graham, Ronald; Donald Knuth; Oren Patashnik (1990). Concrete Mathematics. Chapter 1: Recurrent Problems.

An example in pseudocode

Let's look at an example in pseudocode and talk about what is happening. We're going to sum all of the numbers in an array.

The usual flow of a recursive function is as follows:

  • Perform an operation on the first element (head) of the array.
  • Call the same function (hence recursion) with the remaining elements (tail) of array.
  • Have a guard clause to stop recursion from happening when we've reached the end.
def sum_array
  if the array is empty
    return 0
  else
    head of array + sum_array(tail of array)
  end
end

What happens is sort of like this:

array = [1,2,3,4,5]

1 + 2 + 3 + 4 + 5
1 + 2 + 3 + 9
1 + 2 + 12
1 + 14
15

Recursion vs Iteration

In Ruby it is often preferable to avoid recursion and use iteration instead. Ruby (and most imperative programming languages) have very useful language constructs to aid with iterating over data.

Recursion can end up being slower and use more memory than it's iterative counterpart for a number of reasons discussed here in Stack Overflow.

Certain languages, especially functional languages which deal with immutable data (Elixir, Haskell, etc...), don't have language constructs at all to deal with iteration and all of it is performed through recursion. These languages are optimized for recursion using a technique called tail call optimization and also come with handy pattern matching to deal with the head and tail of arrays.

Why recursion in Ruby?

Despite what I said above, I wanted to see what recursion might look like to solve a number of problems in Ruby. Because Ruby doesn't have an easy way of grabbing the head and tail of an array through pattern matching, I've added a head_tail method to the Array class to aid in this.

class Array
  def head_tail
    head, *tail = *self
    [head, tail]
  end
end

In the array [1,2,3,4,5], the head is 1 and the tail is [2,3,4,5].

Recursion Examples

Factorials

Factorials in math are written like 6! and are the result of 6 * 5 * 4 * 3 * 2 * 1.

def recur_fact(num)
  if num == 0 || num == 1
    1
  else
    num * recur_fact(num - 1)
  end
end

recur_fact(6) # 720

Let's look at the same method done in an iterative manner:

def iter_fact(num)
  if num == 0 || num == 1
    1
  else
    sum = 1
    num.times do |n|
      sum *= (n + 1)
    end
    sum
  end
end

iter_fact(6) # 720

Fibonacci

I heard a funny definition of Fibonacci that goes like this: "Fibonacci - A problem used to teach recursion in computer science." The first 10 Fibonacci numbers go like this: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34 - The next number is the sum of the previous 2 numbers.

def recur_fib(n)
  acc = [0, 1]

  f = ->(acc) {
    if acc.size == n
      acc
    else
      cur, last = acc.last(2)
      f.(acc + [cur + last])
    end
  }

  f.(acc)
end

recur_fib(10) # 0, 1, 1, 2, 3, 5, 8, 13, 21, 34

Summing Array

def recur_sum(array)
  if array.empty?
    0
  else
    head, tail = array.head_tail
    head + recur_sum(tail)
  end
end

recur_sum([1,2,3,4,5]) # 15

Done iteratively:

def iter_sum(array)
  sum = 0
  array.each do |elem|
    sum += elem
  end
  sum
end

iter_sum([1,2,3,4,5]) # 15

Mapping Array

def recur_map(array, f)
  if array.empty?
    []
  else
    head, tail = array.head_tail
    [f.(head)] + recur_map(tail, f)
  end
end

recur_map([1,2,3,4,5], ->(elem) {
  elem * elem
}) # [1, 4, 9, 16, 25]

Done iteratively:

def iter_map(array, f)
  new_array = []
  array.each do |elem|
    new_array << f.(elem)
  end
  new_array
end

iter_map([1,2,3,4,5], ->(elem) {
  elem * elem
}) # [1, 4, 9, 16, 25]

Reducing Array

def recur_reduce(array, acc, f)
  if array.empty?
    acc
  else
    head, tail = array.head_tail
    recur_reduce(tail, f.(acc, head), f)
  end
end

# Join
recur_reduce(["Leigh", "Christopher", "Halliday"], "", ->(r, elem) {
  "#{r} #{elem}".strip
}) # "Leigh Christopher Halliday"

# Sum
recur_reduce([1,2,3,4,5], 0, ->(r, elem) {
  r + elem
}) # 15

# Longest String
recur_reduce(["Leigh", "Christopher", "Halliday"], "", ->(r, elem) {
  r.length > elem.length ? r : elem
}) # "Christopher"

# Count
recur_reduce(["Leigh", "Christopher", "Halliday"], 0, ->(r, elem) {
  r + 1
}) # 3

# Map
recur_reduce([1,2,3,4,5], [], ->(r, elem) {
  r + [elem * elem]
}) # [1, 4, 9, 16, 25]