Here’s my solution to find happy bases - note that I don’t find any
happy bases (aside from 2 and 4) before I run out of memory, somewhere
near base 1700. It wouldn’t surprise me if no other happy bases
exist.
The program checks up to 2*(base-1)*(base-1) for numbers that fall
into an infinite loop (that is not ‘1’ forever) when applying the
digit-square-sum function. This is all that’s needed, as it can
easily be shown that any number will eventually get less than that.
There’s almost certainly some stuff I could do to be more parsimonious
with memory, chief among them finding a copy of narray that has the
.mod! method. (I may revisit this and use a combination of div!, mul!
and sbt! to cut down on temporary arrays) However, this program as it
stands very quickly checks much farther out than I would have thought
necessary if there really were other happy bases out there to be
found.
while true do
dodigsum(base,check)
if check.eq(check_initial).count_true > 2 #Gobs of debugging info
# lp = check.mul!(check.eq(check_initial)).mask(check.ge(2)).min
# puts “#{base} has a loop on #{lp}”
break
end
if check.le(1).count_true > checklimit
puts “#{base} is a happy base”
break
end
end
end
2.upto(3000) { |b|
begin
checkbase(b)
rescue Interrupt
puts “Checking #{b}”
checkbase(b)
rescue Error => e
puts “Bailing on #{b}”
raise e
end
}
And here’s my narray-based solution to find the happiest number under
1_000_000 - it’s not the shortest solution I’ve seen, but it’s pretty
fast. It eliminates numbers that end up in loops by setting all
looping numbers to 0.
onemask now contains the location of “0 order” happy numbers
order = 0
found_ex = nil
while (check.ge(2).count_true > 0) do
check.mul!(check.ne(check_initial))
check = check[checkp]
newmask = check.eq(1)
order = order + 1
if (not newmask == onemask)
found_ex = [newmask.gt(onemask).where.min, order]
end
onemask = newmask
end
puts “Happiest is #{found_ex[0]}, with happiness order #{found_ex[1]}” END
Here’s my solution to find happy bases - note that I don’t find any
happy bases (aside from 2 and 4) before I run out of memory, somewhere
near base 1700. It wouldn’t surprise me if no other happy bases
exist.
I used the attached program to check for happy bases.
$ time ruby hapnr2.rb 10000
2
4
real 1m7.279s
user 1m7.261s
sys 0m0.013s
So, there are no more happy bases up to 10000.
Regards,
Michael
–
Michael U.
R&D Team
ISIS Information Systems Austria
tel: +43 2236 27551-219, fax: +43 2236 21081
e-mail: [email protected]
Visit our Website: www.isis-papyrus.com
Here’s my solution to find happy bases - note that I don’t find any
happy bases (aside from 2 and 4) before I run out of memory, somewhere
near base 1700. It wouldn’t surprise me if no other happy bases
exist.
And here’s a faster version, and I also corrected the “Error” to
“Exception” mistake I’d made in my earlier version. This version
makes it through bases 2 - 100 in the blink of an eye, but really
starts to slow down around base 700.
I haven’t had a chance to run this one as far as it can go without
running out of memory; maybe later today.
while true do
if check.eq(check_initial).count_true > 2 #lp = check.mul!(check.eq(check_initial)).mask(check.ge(2)).min #puts “#{base} has a loop on #{lp}”
print (base % 100 > 0 ? “.” : “x”)
break
end
if check.le(1).count_true > checklimit
puts “#{base} is a happy base”
break
end
check[0] = check[checkp]
end
end
2.upto(3000) { |b|
begin
checkbase(b)
GC.start if (b > 300 and b % 5 == 0)
sleep(1) if (b % 100 == 0)
rescue Interrupt
puts “Checking #{b}”
checkbase(b)
rescue Exception => e
puts “Bailing on #{b}”
raise e
end
}
END
This forum is not affiliated to the Ruby language, Ruby on Rails framework, nor any Ruby applications discussed here.