Alan McConnel pointed me to this problem.

Having written the program I have some questions.
      Is it in good ruby style?
      How could it be improved?
      Is there a way to trade RAM for speed?
      How does it do arithmetic on very long strings w/o taking more
RAM?

John

Program follows:

=begin
 Test the hypothesis that for any integer the process of adding it to
 its reverse will eventually yield a palindrome, For example,
 consider 69:  69+96=165;165+561=726;726+627=1353;1353+3531=4884

 I rubified this and discovered this phenom:
         The number 169 does not settle on a palindrome after
         more than 62k tries. But while the program slows to two
         tials a minute on a 233Mhz Pentiun, it does not increase
         in RAM used. The length of the number generated
         for a try is .41 times the try number. So attempt
         62,000 involves adding 2 numbers 25,420 digits long.

         Actually, the program decreased in size after it had
         been running for a  short while. I imagine that the decrease
         came at a gc following the switch to bignuum.
=end

trylimit = 10
160.upto(170) do |j|             # check 160 to 170 for
palindromeability

  tststr = j.to_s                      # Would a reverse method for
bignum help?
  palfound = false                 # unnecesary variable?

  trylimit.times do |tries|
#puts tststr                        ############  trace
    newstr = (tststr.to_i + tststr.reverse.to_i).to_s
    if newstr == newstr.reverse
#print " pal ", newstr, "\n"        ############# trace
      palfound = true
      break
    else
      tststr = newstr
    end
end
    print j, " No palindrome in ", trylimit, " tries.\n"   unless
palfound
end