```Which way is the eloquent ruby way to write this algorithm?

Kaprekar Number

9 is a Kaprekar number since
9 ^ 2 = 81 and 8 + 1 = 9

297 is also Kaprekar number since
297 ^ 2 = 88209 and 88 + 209 = 297.

In short, for a Kaprekar number k with n-digits, if you square it and
add the right n digits to the left n or n-1 digits, the resultant sum is
k.

!Spoiler Below!

# way one
def kaprekar?(k)
ks = k**2
lenf = (ks.to_s.length)-1
lenh = (ks.to_s.length / 2) - 1
a = ks.to_s[0..lenh].to_i
b = ks.to_s[lenh+1..lenf].to_i
k == (a+b)
end

# way two
def kaprekar?(k)
a = (k**2).to_s[0..((((k**2).to_s.length) / 2) - 1)].to_i
b = (k**2).to_s[(((((k**2).to_s.length) / 2) -
1)+1)..(((k**2).to_s.length)-1)].to_i
k == (a+b)
end

# way three
def kaprekar?(k)
k == ((k**2).to_s[0..((((k**2).to_s.length) / 2) -
1)].to_i)+((k**2).to_s[(((((k**2).to_s.length) / 2) -
1)+1)..(((k**2).to_s.length)-1)].to_i)
end

def  simple_test(i)
if kaprekar?(i) == true then p "success on #{i}" else "fail on #{i}"
end
end

simple_test(9)
simple_test(297)

All three pass my tests, but which of the three would be considered the
most eloquent written ruby way? As in, which would be consider best
style-wise? The first takes up the most lines, but uses less nesting.
The last uses only one line but uses lots of nesting.

--
Posted via http://www.ruby-forum.com/.

```