```Here's my solution.

There are arguments which control what the main program does.

-b , or --base is an integer giving the base - this defaults to 10
-t, or --time-limit  is an integer giving the number of seconds to run
looking for the happiest number in a give base.  This defaults to 600
seconds (10 minutes)
--levels causes an unlimited time run which prints a "happiest" number
of numbers with the same number of digits in the base.  Use break to
stop this.

I cache both unhappy numbers and successful paths so that I can
short-circuit things.  Not a small memory solution.

== happynumber.rb ==
#! /usr/local/bin/ruby

class Integer

def Integer.reset_happiness_cache
# Integer#to_s(base) works up to a base of 36
@@cached_unhappy_ints = Array.new(37) {|i| Hash.new }
@@cached_happiness_paths = Array.new(37) {|i| {1 => }}

self.cache_unhappy([0, 4, 16, 20, 37, 42, 58, 89, 145], 10)
end

def Integer.show_hc
puts "unhappies = #{@@cached_unhappy_ints.inspect}"
puts "happies = #{@@cached_happiness_paths.inspect}"
end

def squared
self * self
end

def sum_squares_of_digits(base=10)
sum = 0
to_s(base).each_byte do |b|
sum += (b.chr.to_i(base)).squared
end
sum
end

def path_to_happiness(base=10,seen=[])
return nil if Integer.known_unhappy?(self, base)
return Integer.cache_unhappy([self], base) if
seen.include?(self)
known_path = Integer.known_happiness_path(self, base)
return known_path.dup if known_path
rest_of_the_way =
sum_squares_of_digits(base).path_to_happiness(base,seen.dup << self)
if rest_of_the_way
ans = rest_of_the_way.unshift(self)
return Integer.cache_happiness_path(ans, base).dup
else
Integer.cache_unhappy([self], base)
return nil
end
end

def Integer.known_unhappy?(int, base)
@@cached_unhappy_ints[base][int]
end

def Integer.known_happiness_path(int, base)
@@cached_happiness_paths[ base][int]
end

def known_happy?(base)
Integer.known_happiness_path(self, base)
end

def Integer.cache_unhappy(integers, base)
integers.each do | n |
@@cached_unhappy_ints[base][n] = true
end
nil
end

def Integer.cache_happiness_path(path, base)
@@cached_happiness_paths[base][path] = path.dup
path
end

def happy?
!self.path_to_happiness.nil?
end

def happiness
path = path_to_happiness
path_to_happiness ? path_to_happiness.length : 0
end

reset_happiness_cache
end

#generates all numbers in the given range whose digits are in
#nondecreasing order. the order in which the numbers are generated is
#undefined, so it's possible for 123 to appear before 23, for
#example.
# Thanks to Ken Bloom for this idea, which I generalized to an arbitrary base
#
def nondec_digits(range,base=10,&b)
yield 0 if range.first<=0
(1..base-1).each { |x| nondec_digits_internal(x,x,range,base,&b) }
end

def nondec_digits_internal(last,accum,range,base,&b)
(last..base-1).each do |x|
iaccum=accum*base+x
b.call(iaccum) if range.nil? || range.include?(iaccum)
nondec_digits_internal(x,iaccum,range,base,&b) if
iaccum <= range.last
end
end

# enumerate all numbers whose representation in base _base_
# has increasing digits.
def nondec_numbers(base, &b)
start = 0
ten_in_base = "10".to_i(base)
stop = ten_in_base
while true
nondec_digits((start..stop-1), base, &b)
start = stop
stop *= ten_in_base
end
end

def happiest_in_range(range, base=10)
happiest = 1
max_path_length = 1
probes = 0
nondec_digits(range,base) do |i|
probes += 1
path = i.path_to_happiness(base)
if path && path.length > max_path_length
happiest = i
max_path_length = path.length
end
end
[happiest, max_path_length, probes]
end

def base_levels(base=10)
ten_in_base = "10".to_i(base)
start = 0
base_n = ten_in_base
n = 1
while true
h, pl, probes = happiest_in_range((start..base_n-1), base)
puts "one of the happiest #{n} digit base #{base}
numbers is #{h.to_s(base)}, with #{pl} steps after #{probes} probes"
start = base_n
n += 1
base_n *= ten_in_base
end
end

# return the happiest number that can be found in time_limit seconds
def happiest(time_limit=60, base=10)
time_to_stop = Time.now + time_limit
happiest = 1
max_path_length = 1
probes = 0
nondec_numbers(base) do |i|
break if Time.now > time_to_stop
probes += 1
path = i.path_to_happiness(base)
if path && path.length > max_path_length
happiest = i
max_path_length = path.length
end
end

puts "happiest base #{base} number found in #{time_limit}
seconds in #{probes} probes"
puts "was #{happiest.to_s(base)} which has a happiness of
#{max_path_length}"
end

require 'optparse'
opts = OptionParser.new
base = 10
time_limit = 600 # default to 10 minutes
happiest_test = true
opts.on("-b", "--base VAL", Integer) {|val| base = val}
opts.on("--levels") {happiest_test = false}
opts.on("-t", "--time-limit VAL", Integer) {|val| time_limit = val}
opts.parse(ARGV)
happiest(time_limit, base) if happiest_test
base_levels(base) unless happiest_test

--
Rick DeNatale

My blog on Ruby