Here are my two solutions. Both take arbitrary bases. Neither counts
the number of steps between a number and its happiness. The hash-based
one is based on the auto-memoizing idea previously discussed on this
list for a speedy fibonacci calculation.

The core of both calculations is calculating the next happy step via:
num.to_s(base).split('').map{ |c| c.to_i(base)**2 }.inject{ |s,i| s+i }

class Integer
 @@happysteps = Hash.new{ |k,v| k[v] = {} }
 def happy?( base=10 )
  seen = {}
  num = self
  until num==1 or seen[ num ]
   seen[ num ] = true
   num = num.to_s(base).split('').map{ |c| c.to_i(base)**2 }.inject{
|s,i| s+i }
  end
  num == 1
 end
end

happy = Hash.new{ |h1,base|
 h1[ base ] = Hash.new{ |h2, n|
  if n == 1
   h2[ 1 ] = true
  else
   h2[ n ] = :not_happy
   sum_of_squares = n.to_s(base).split('').map{ |c| c.to_i(base)**2
}.inject{ |s,i| s+i }
   if sum_of_squares == 1
    h2[ n ] = true
   else
    subn = h2[ sum_of_squares ]
    if subn == true
     h2[ n ] = true
    elsif subn == false || subn == :not_happy
     h2[ n ] = h2[ sum_of_squares ] = false
    end
   end
  end
 }
}


range = 1..1000
puts "How many Happy numbers between #{range}?"
3.upto(36){ |base|
 puts "Base #{base}: #{range.select{|i| happy[ base ][ i ] }.length}
happy numbers."
 puts "Base #{base}: #{range.select{|i| i.happy?( base ) }.length}
happy numbers."
}